/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

Bug Summary

File:	llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp
Warning:	line 786, column 22 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name AggressiveAntiDepBreaker.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/CodeGen -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

→

1//===- AggressiveAntiDepBreaker.cpp - Anti-dep breaker --------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the AggressiveAntiDepBreaker class, which
10// implements register anti-dependence breaking during post-RA
11// scheduling. It attempts to break all anti-dependencies within a
12// block.
13//
14//===----------------------------------------------------------------------===//

16#include "AggressiveAntiDepBreaker.h"
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/SmallSet.h"
19#include "llvm/ADT/iterator_range.h"
20#include "llvm/CodeGen/MachineBasicBlock.h"
21#include "llvm/CodeGen/MachineFrameInfo.h"
22#include "llvm/CodeGen/MachineFunction.h"
23#include "llvm/CodeGen/MachineInstr.h"
24#include "llvm/CodeGen/MachineOperand.h"
25#include "llvm/CodeGen/MachineRegisterInfo.h"
26#include "llvm/CodeGen/RegisterClassInfo.h"
27#include "llvm/CodeGen/ScheduleDAG.h"
28#include "llvm/CodeGen/TargetInstrInfo.h"
29#include "llvm/CodeGen/TargetRegisterInfo.h"
30#include "llvm/MC/MCInstrDesc.h"
31#include "llvm/MC/MCRegisterInfo.h"
32#include "llvm/Support/CommandLine.h"
33#include "llvm/Support/Debug.h"
34#include "llvm/Support/MachineValueType.h"
35#include "llvm/Support/raw_ostream.h"
36#include <cassert>
37#include <utility>

39using namespace llvm;

41#define DEBUG_TYPE"post-RA-sched" "post-RA-sched"

43// If DebugDiv > 0 then only break antidep with (ID % DebugDiv) == DebugMod
44static cl::opt<int>
45DebugDiv("agg-antidep-debugdiv",
       cl::desc("Debug control for aggressive anti-dep breaker"),
       cl::init(0), cl::Hidden);

49static cl::opt<int>
50DebugMod("agg-antidep-debugmod",
       cl::desc("Debug control for aggressive anti-dep breaker"),
       cl::init(0), cl::Hidden);

54AggressiveAntiDepState::AggressiveAntiDepState(const unsigned TargetRegs,
                                             MachineBasicBlock *BB)
  : NumTargetRegs(TargetRegs), GroupNodes(TargetRegs, 0),
    GroupNodeIndices(TargetRegs, 0), KillIndices(TargetRegs, 0),
    DefIndices(TargetRegs, 0) {
const unsigned BBSize = BB->size();
for (unsigned i = 0; i < NumTargetRegs; ++i) {
  // Initialize all registers to be in their own group. Initially we
  // assign the register to the same-indexed GroupNode.
  GroupNodeIndices[i] = i;
  // Initialize the indices to indicate that no registers are live.
  KillIndices[i] = ~0u;
  DefIndices[i] = BBSize;
}
68}

70unsigned AggressiveAntiDepState::GetGroup(unsigned Reg) {
unsigned Node = GroupNodeIndices[Reg];
while (GroupNodes[Node] != Node)
  Node = GroupNodes[Node];

return Node;
76}

78void AggressiveAntiDepState::GetGroupRegs(
unsigned Group,
std::vector<unsigned> &Regs,
std::multimap<unsigned, AggressiveAntiDepState::RegisterReference> *RegRefs)
82{
for (unsigned Reg = 0; Reg != NumTargetRegs; ++Reg) {
  if ((GetGroup(Reg) == Group) && (RegRefs->count(Reg) > 0))
    Regs.push_back(Reg);
}
87}

89unsigned AggressiveAntiDepState::UnionGroups(unsigned Reg1, unsigned Reg2) {
assert(GroupNodes[0] == 0 && "GroupNode 0 not parent!")(static_cast<void> (0));
assert(GroupNodeIndices[0] == 0 && "Reg 0 not in Group 0!")(static_cast<void> (0));

// find group for each register
unsigned Group1 = GetGroup(Reg1);
unsigned Group2 = GetGroup(Reg2);

// if either group is 0, then that must become the parent
unsigned Parent = (Group1 == 0) ? Group1 : Group2;
unsigned Other = (Parent == Group1) ? Group2 : Group1;
GroupNodes.at(Other) = Parent;
return Parent;
102}

104unsigned AggressiveAntiDepState::LeaveGroup(unsigned Reg) {
// Create a new GroupNode for Reg. Reg's existing GroupNode must
// stay as is because there could be other GroupNodes referring to
// it.
unsigned idx = GroupNodes.size();
GroupNodes.push_back(idx);
GroupNodeIndices[Reg] = idx;
return idx;
112}

114bool AggressiveAntiDepState::IsLive(unsigned Reg) {
// KillIndex must be defined and DefIndex not defined for a register
// to be live.
return((KillIndices[Reg] != ~0u) && (DefIndices[Reg] == ~0u));
118}

120AggressiveAntiDepBreaker::AggressiveAntiDepBreaker(
  MachineFunction &MFi, const RegisterClassInfo &RCI,
  TargetSubtargetInfo::RegClassVector &CriticalPathRCs)
  : AntiDepBreaker(), MF(MFi), MRI(MF.getRegInfo()),
    TII(MF.getSubtarget().getInstrInfo()),
    TRI(MF.getSubtarget().getRegisterInfo()), RegClassInfo(RCI) {
/* Collect a bitset of all registers that are only broken if they
   are on the critical path. */
for (unsigned i = 0, e = CriticalPathRCs.size(); i < e; ++i) {
  BitVector CPSet = TRI->getAllocatableSet(MF, CriticalPathRCs[i]);
  if (CriticalPathSet.none())
    CriticalPathSet = CPSet;
  else
    CriticalPathSet |= CPSet;
 }

 LLVM_DEBUG(dbgs() << "AntiDep Critical-Path Registers:")do { } while (false);
 LLVM_DEBUG(for (unsigned rdo { } while (false)
                 : CriticalPathSet.set_bits()) dbgs()do { } while (false)
            << " " << printReg(r, TRI))do { } while (false);
 LLVM_DEBUG(dbgs() << '\n')do { } while (false);
141}

143AggressiveAntiDepBreaker::~AggressiveAntiDepBreaker() {
delete State;
145}

147void AggressiveAntiDepBreaker::StartBlock(MachineBasicBlock *BB) {
assert(!State)(static_cast<void> (0));
State = new AggressiveAntiDepState(TRI->getNumRegs(), BB);

bool IsReturnBlock = BB->isReturnBlock();
std::vector<unsigned> &KillIndices = State->GetKillIndices();
std::vector<unsigned> &DefIndices = State->GetDefIndices();

// Examine the live-in regs of all successors.
for (MachineBasicBlock *Succ : BB->successors())
  for (const auto &LI : Succ->liveins()) {
    for (MCRegAliasIterator AI(LI.PhysReg, TRI, true); AI.isValid(); ++AI) {
      unsigned Reg = *AI;
      State->UnionGroups(Reg, 0);
      KillIndices[Reg] = BB->size();
      DefIndices[Reg] = ~0u;
    }
  }

// Mark live-out callee-saved registers. In a return block this is
// all callee-saved registers. In non-return this is any
// callee-saved register that is not saved in the prolog.
const MachineFrameInfo &MFI = MF.getFrameInfo();
BitVector Pristine = MFI.getPristineRegs(MF);
for (const MCPhysReg *I = MF.getRegInfo().getCalleeSavedRegs(); *I;
     ++I) {
  unsigned Reg = *I;
  if (!IsReturnBlock && !Pristine.test(Reg))
    continue;
  for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI) {
    unsigned AliasReg = *AI;
    State->UnionGroups(AliasReg, 0);
    KillIndices[AliasReg] = BB->size();
    DefIndices[AliasReg] = ~0u;
  }
}
183}

185void AggressiveAntiDepBreaker::FinishBlock() {
delete State;
State = nullptr;
188}

190void AggressiveAntiDepBreaker::Observe(MachineInstr &MI, unsigned Count,
                                     unsigned InsertPosIndex) {
assert(Count < InsertPosIndex && "Instruction index out of expected range!")(static_cast<void> (0));

std::set<unsigned> PassthruRegs;
GetPassthruRegs(MI, PassthruRegs);
PrescanInstruction(MI, Count, PassthruRegs);
ScanInstruction(MI, Count);

LLVM_DEBUG(dbgs() << "Observe: ")do { } while (false);
LLVM_DEBUG(MI.dump())do { } while (false);
LLVM_DEBUG(dbgs() << "\tRegs:")do { } while (false);

std::vector<unsigned> &DefIndices = State->GetDefIndices();
for (unsigned Reg = 0; Reg != TRI->getNumRegs(); ++Reg) {
  // If Reg is current live, then mark that it can't be renamed as
  // we don't know the extent of its live-range anymore (now that it
  // has been scheduled). If it is not live but was defined in the
  // previous schedule region, then set its def index to the most
  // conservative location (i.e. the beginning of the previous
  // schedule region).
  if (State->IsLive(Reg)) {
    LLVM_DEBUG(if (State->GetGroup(Reg) != 0) dbgs()do { } while (false)
               << " " << printReg(Reg, TRI) << "=g" << State->GetGroup(Reg)do { } while (false)
               << "->g0(region live-out)")do { } while (false);
    State->UnionGroups(Reg, 0);
  } else if ((DefIndices[Reg] < InsertPosIndex)
             && (DefIndices[Reg] >= Count)) {
    DefIndices[Reg] = Count;
  }
}
LLVM_DEBUG(dbgs() << '\n')do { } while (false);
222}

224bool AggressiveAntiDepBreaker::IsImplicitDefUse(MachineInstr &MI,
                                              MachineOperand &MO) {
if (!MO.isReg() || !MO.isImplicit())
  return false;

Register Reg = MO.getReg();
if (Reg == 0)
  return false;

MachineOperand *Op = nullptr;
if (MO.isDef())
  Op = MI.findRegisterUseOperand(Reg, true);
else
  Op = MI.findRegisterDefOperand(Reg);

return(Op && Op->isImplicit());
240}

242void AggressiveAntiDepBreaker::GetPassthruRegs(
  MachineInstr &MI, std::set<unsigned> &PassthruRegs) {
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
  MachineOperand &MO = MI.getOperand(i);
  if (!MO.isReg()) continue;
  if ((MO.isDef() && MI.isRegTiedToUseOperand(i)) ||
      IsImplicitDefUse(MI, MO)) {
    const Register Reg = MO.getReg();
    for (MCSubRegIterator SubRegs(Reg, TRI, /*IncludeSelf=*/true);
         SubRegs.isValid(); ++SubRegs)
      PassthruRegs.insert(*SubRegs);
  }
}
255}

257/// AntiDepEdges - Return in Edges the anti- and output- dependencies
258/// in SU that we want to consider for breaking.
259static void AntiDepEdges(const SUnit *SU, std::vector<const SDep *> &Edges) {
SmallSet<unsigned, 4> RegSet;
for (const SDep &Pred : SU->Preds) {
  if ((Pred.getKind() == SDep::Anti) || (Pred.getKind() == SDep::Output)) {
    if (RegSet.insert(Pred.getReg()).second)
      Edges.push_back(&Pred);
  }
}
267}

269/// CriticalPathStep - Return the next SUnit after SU on the bottom-up
270/// critical path.
271static const SUnit *CriticalPathStep(const SUnit *SU) {
const SDep *Next = nullptr;
unsigned NextDepth = 0;
// Find the predecessor edge with the greatest depth.
if (SU) {
  for (const SDep &Pred : SU->Preds) {
    const SUnit *PredSU = Pred.getSUnit();
    unsigned PredLatency = Pred.getLatency();
    unsigned PredTotalLatency = PredSU->getDepth() + PredLatency;
    // In the case of a latency tie, prefer an anti-dependency edge over
    // other types of edges.
    if (NextDepth < PredTotalLatency ||
        (NextDepth == PredTotalLatency && Pred.getKind() == SDep::Anti)) {
      NextDepth = PredTotalLatency;
      Next = &Pred;
    }
  }
}

return (Next) ? Next->getSUnit() : nullptr;
291}

293void AggressiveAntiDepBreaker::HandleLastUse(unsigned Reg, unsigned KillIdx,
                                           const char *tag,
                                           const char *header,
                                           const char *footer) {
std::vector<unsigned> &KillIndices = State->GetKillIndices();
std::vector<unsigned> &DefIndices = State->GetDefIndices();
std::multimap<unsigned, AggressiveAntiDepState::RegisterReference>&
  RegRefs = State->GetRegRefs();

// FIXME: We must leave subregisters of live super registers as live, so that
// we don't clear out the register tracking information for subregisters of
// super registers we're still tracking (and with which we're unioning
// subregister definitions).
for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
  if (TRI->isSuperRegister(Reg, *AI) && State->IsLive(*AI)) {
    LLVM_DEBUG(if (!header && footer) dbgs() << footer)do { } while (false);
    return;
  }

if (!State->IsLive(Reg)) {
  KillIndices[Reg] = KillIdx;
  DefIndices[Reg] = ~0u;
  RegRefs.erase(Reg);
  State->LeaveGroup(Reg);
  LLVM_DEBUG(if (header) {do { } while (false)
    dbgs() << header << printReg(Reg, TRI);do { } while (false)
    header = nullptr;do { } while (false)
  })do { } while (false);
  LLVM_DEBUG(dbgs() << "->g" << State->GetGroup(Reg) << tag)do { } while (false);
  // Repeat for subregisters. Note that we only do this if the superregister
  // was not live because otherwise, regardless whether we have an explicit
  // use of the subregister, the subregister's contents are needed for the
  // uses of the superregister.
  for (MCSubRegIterator SubRegs(Reg, TRI); SubRegs.isValid(); ++SubRegs) {
    unsigned SubregReg = *SubRegs;
    if (!State->IsLive(SubregReg)) {
      KillIndices[SubregReg] = KillIdx;
      DefIndices[SubregReg] = ~0u;
      RegRefs.erase(SubregReg);
      State->LeaveGroup(SubregReg);
      LLVM_DEBUG(if (header) {do { } while (false)
        dbgs() << header << printReg(Reg, TRI);do { } while (false)
        header = nullptr;do { } while (false)
      })do { } while (false);
      LLVM_DEBUG(dbgs() << " " << printReg(SubregReg, TRI) << "->g"do { } while (false)
                        << State->GetGroup(SubregReg) << tag)do { } while (false);
    }
  }
}

LLVM_DEBUG(if (!header && footer) dbgs() << footer)do { } while (false);
344}

346void AggressiveAntiDepBreaker::PrescanInstruction(
  MachineInstr &MI, unsigned Count, std::set<unsigned> &PassthruRegs) {
std::vector<unsigned> &DefIndices = State->GetDefIndices();
std::multimap<unsigned, AggressiveAntiDepState::RegisterReference>&
  RegRefs = State->GetRegRefs();

// Handle dead defs by simulating a last-use of the register just
// after the def. A dead def can occur because the def is truly
// dead, or because only a subregister is live at the def. If we
// don't do this the dead def will be incorrectly merged into the
// previous def.
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
  MachineOperand &MO = MI.getOperand(i);
  if (!MO.isReg() || !MO.isDef()) continue;
  Register Reg = MO.getReg();
  if (Reg == 0) continue;

  HandleLastUse(Reg, Count + 1, "", "\tDead Def: ", "\n");
}

LLVM_DEBUG(dbgs() << "\tDef Groups:")do { } while (false);
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
  MachineOperand &MO = MI.getOperand(i);
  if (!MO.isReg() || !MO.isDef()) continue;
  Register Reg = MO.getReg();
  if (Reg == 0) continue;

  LLVM_DEBUG(dbgs() << " " << printReg(Reg, TRI) << "=g"do { } while (false)
                    << State->GetGroup(Reg))do { } while (false);

  // If MI's defs have a special allocation requirement, don't allow
  // any def registers to be changed. Also assume all registers
  // defined in a call must not be changed (ABI). Inline assembly may
  // reference either system calls or the register directly. Skip it until we
  // can tell user specified registers from compiler-specified.
  if (MI.isCall() || MI.hasExtraDefRegAllocReq() || TII->isPredicated(MI) ||
      MI.isInlineAsm()) {
    LLVM_DEBUG(if (State->GetGroup(Reg) != 0) dbgs() << "->g0(alloc-req)")do { } while (false);
    State->UnionGroups(Reg, 0);
  }

  // Any aliased that are live at this point are completely or
  // partially defined here, so group those aliases with Reg.
  for (MCRegAliasIterator AI(Reg, TRI, false); AI.isValid(); ++AI) {
    unsigned AliasReg = *AI;
    if (State->IsLive(AliasReg)) {
      State->UnionGroups(Reg, AliasReg);
      LLVM_DEBUG(dbgs() << "->g" << State->GetGroup(Reg) << "(via "do { } while (false)
                        << printReg(AliasReg, TRI) << ")")do { } while (false);
    }
  }

  // Note register reference...
  const TargetRegisterClass *RC = nullptr;
  if (i < MI.getDesc().getNumOperands())
    RC = TII->getRegClass(MI.getDesc(), i, TRI, MF);
  AggressiveAntiDepState::RegisterReference RR = { &MO, RC };
  RegRefs.insert(std::make_pair(Reg, RR));
}

LLVM_DEBUG(dbgs() << '\n')do { } while (false);

// Scan the register defs for this instruction and update
// live-ranges.
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
  MachineOperand &MO = MI.getOperand(i);
  if (!MO.isReg() || !MO.isDef()) continue;
  Register Reg = MO.getReg();
  if (Reg == 0) continue;
  // Ignore KILLs and passthru registers for liveness...
  if (MI.isKill() || (PassthruRegs.count(Reg) != 0))
    continue;

  // Update def for Reg and aliases.
  for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI) {
    // We need to be careful here not to define already-live super registers.
    // If the super register is already live, then this definition is not
    // a definition of the whole super register (just a partial insertion
    // into it). Earlier subregister definitions (which we've not yet visited
    // because we're iterating bottom-up) need to be linked to the same group
    // as this definition.
    if (TRI->isSuperRegister(Reg, *AI) && State->IsLive(*AI))
      continue;

    DefIndices[*AI] = Count;
  }
}
433}

435void AggressiveAntiDepBreaker::ScanInstruction(MachineInstr &MI,
                                             unsigned Count) {
LLVM_DEBUG(dbgs() << "\tUse Groups:")do { } while (false);
std::multimap<unsigned, AggressiveAntiDepState::RegisterReference>&
  RegRefs = State->GetRegRefs();

// If MI's uses have special allocation requirement, don't allow
// any use registers to be changed. Also assume all registers
// used in a call must not be changed (ABI).
// Inline Assembly register uses also cannot be safely changed.
// FIXME: The issue with predicated instruction is more complex. We are being
// conservatively here because the kill markers cannot be trusted after
// if-conversion:
// %r6 = LDR %sp, %reg0, 92, 14, %reg0; mem:LD4[FixedStack14]
// ...
// STR %r0, killed %r6, %reg0, 0, 0, %cpsr; mem:ST4[%395]
// %r6 = LDR %sp, %reg0, 100, 0, %cpsr; mem:LD4[FixedStack12]
// STR %r0, killed %r6, %reg0, 0, 14, %reg0; mem:ST4[%396](align=8)
//
// The first R6 kill is not really a kill since it's killed by a predicated
// instruction which may not be executed. The second R6 def may or may not
// re-define R6 so it's not safe to change it since the last R6 use cannot be
// changed.
bool Special = MI.isCall() || MI.hasExtraSrcRegAllocReq() ||
               TII->isPredicated(MI) || MI.isInlineAsm();

// Scan the register uses for this instruction and update
// live-ranges, groups and RegRefs.
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
  MachineOperand &MO = MI.getOperand(i);
  if (!MO.isReg() || !MO.isUse()) continue;
  Register Reg = MO.getReg();
  if (Reg == 0) continue;

  LLVM_DEBUG(dbgs() << " " << printReg(Reg, TRI) << "=g"do { } while (false)
                    << State->GetGroup(Reg))do { } while (false);

  // It wasn't previously live but now it is, this is a kill. Forget
  // the previous live-range information and start a new live-range
  // for the register.
  HandleLastUse(Reg, Count, "(last-use)");

  if (Special) {
    LLVM_DEBUG(if (State->GetGroup(Reg) != 0) dbgs() << "->g0(alloc-req)")do { } while (false);
    State->UnionGroups(Reg, 0);
  }

  // Note register reference...
  const TargetRegisterClass *RC = nullptr;
  if (i < MI.getDesc().getNumOperands())
    RC = TII->getRegClass(MI.getDesc(), i, TRI, MF);
  AggressiveAntiDepState::RegisterReference RR = { &MO, RC };
  RegRefs.insert(std::make_pair(Reg, RR));
}

LLVM_DEBUG(dbgs() << '\n')do { } while (false);

// Form a group of all defs and uses of a KILL instruction to ensure
// that all registers are renamed as a group.
if (MI.isKill()) {
  LLVM_DEBUG(dbgs() << "\tKill Group:")do { } while (false);

  unsigned FirstReg = 0;
  for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
    MachineOperand &MO = MI.getOperand(i);
    if (!MO.isReg()) continue;
    Register Reg = MO.getReg();
    if (Reg == 0) continue;

    if (FirstReg != 0) {
      LLVM_DEBUG(dbgs() << "=" << printReg(Reg, TRI))do { } while (false);
      State->UnionGroups(FirstReg, Reg);
    } else {
      LLVM_DEBUG(dbgs() << " " << printReg(Reg, TRI))do { } while (false);
      FirstReg = Reg;
    }
  }

  LLVM_DEBUG(dbgs() << "->g" << State->GetGroup(FirstReg) << '\n')do { } while (false);
}
515}

517BitVector AggressiveAntiDepBreaker::GetRenameRegisters(unsigned Reg) {
BitVector BV(TRI->getNumRegs(), false);
bool first = true;

// Check all references that need rewriting for Reg. For each, use
// the corresponding register class to narrow the set of registers
// that are appropriate for renaming.
for (const auto &Q : make_range(State->GetRegRefs().equal_range(Reg))) {
  const TargetRegisterClass *RC = Q.second.RC;
  if (!RC) continue;

  BitVector RCBV = TRI->getAllocatableSet(MF, RC);
  if (first) {
    BV |= RCBV;
    first = false;
  } else {
    BV &= RCBV;
  }

  LLVM_DEBUG(dbgs() << " " << TRI->getRegClassName(RC))do { } while (false);
}

return BV;
540}

542bool AggressiveAntiDepBreaker::FindSuitableFreeRegisters(
                              unsigned AntiDepGroupIndex,
                              RenameOrderType& RenameOrder,
                              std::map<unsigned, unsigned> &RenameMap) {
std::vector<unsigned> &KillIndices = State->GetKillIndices();
std::vector<unsigned> &DefIndices = State->GetDefIndices();
std::multimap<unsigned, AggressiveAntiDepState::RegisterReference>&
  RegRefs = State->GetRegRefs();

// Collect all referenced registers in the same group as
// AntiDepReg. These all need to be renamed together if we are to
// break the anti-dependence.
std::vector<unsigned> Regs;
State->GetGroupRegs(AntiDepGroupIndex, Regs, &RegRefs);
assert(!Regs.empty() && "Empty register group!")(static_cast<void> (0));
if (Regs.empty())
  return false;

// Find the "superest" register in the group. At the same time,
// collect the BitVector of registers that can be used to rename
// each register.
LLVM_DEBUG(dbgs() << "\tRename Candidates for Group g" << AntiDepGroupIndexdo { } while (false)
                  << ":\n")do { } while (false);
std::map<unsigned, BitVector> RenameRegisterMap;
unsigned SuperReg = 0;
for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
  unsigned Reg = Regs[i];
  if ((SuperReg == 0) || TRI->isSuperRegister(SuperReg, Reg))
    SuperReg = Reg;

  // If Reg has any references, then collect possible rename regs
  if (RegRefs.count(Reg) > 0) {
    LLVM_DEBUG(dbgs() << "\t\t" << printReg(Reg, TRI) << ":")do { } while (false);

    BitVector &BV = RenameRegisterMap[Reg];
    assert(BV.empty())(static_cast<void> (0));
    BV = GetRenameRegisters(Reg);

    LLVM_DEBUG({do { } while (false)
      dbgs() << " ::";do { } while (false)
      for (unsigned r : BV.set_bits())do { } while (false)
        dbgs() << " " << printReg(r, TRI);do { } while (false)
      dbgs() << "\n";do { } while (false)
    })do { } while (false);
  }
}

// All group registers should be a subreg of SuperReg.
for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
  unsigned Reg = Regs[i];
  if (Reg == SuperReg) continue;
  bool IsSub = TRI->isSubRegister(SuperReg, Reg);
  // FIXME: remove this once PR18663 has been properly fixed. For now,
  // return a conservative answer:
  // assert(IsSub && "Expecting group subregister");
  if (!IsSub)
    return false;
}

601#ifndef NDEBUG1
// If DebugDiv > 0 then only rename (renamecnt % DebugDiv) == DebugMod
if (DebugDiv > 0) {
  static int renamecnt = 0;
  if (renamecnt++ % DebugDiv != DebugMod)
    return false;

  dbgs() << "*** Performing rename " << printReg(SuperReg, TRI)
         << " for debug ***\n";
}
611#endif

// Check each possible rename register for SuperReg in round-robin
// order. If that register is available, and the corresponding
// registers are available for the other group subregisters, then we
// can use those registers to rename.

// FIXME: Using getMinimalPhysRegClass is very conservative. We should
// check every use of the register and find the largest register class
// that can be used in all of them.
const TargetRegisterClass *SuperRC =
  TRI->getMinimalPhysRegClass(SuperReg, MVT::Other);

ArrayRef<MCPhysReg> Order = RegClassInfo.getOrder(SuperRC);
if (Order.empty()) {
  LLVM_DEBUG(dbgs() << "\tEmpty Super Regclass!!\n")do { } while (false);
  return false;
}

LLVM_DEBUG(dbgs() << "\tFind Registers:")do { } while (false);

RenameOrder.insert(RenameOrderType::value_type(SuperRC, Order.size()));

unsigned OrigR = RenameOrder[SuperRC];
unsigned EndR = ((OrigR == Order.size()) ? 0 : OrigR);
unsigned R = OrigR;
do {
  if (R == 0) R = Order.size();
  --R;
  const unsigned NewSuperReg = Order[R];
  // Don't consider non-allocatable registers
  if (!MRI.isAllocatable(NewSuperReg)) continue;
  // Don't replace a register with itself.
  if (NewSuperReg == SuperReg) continue;

  LLVM_DEBUG(dbgs() << " [" << printReg(NewSuperReg, TRI) << ':')do { } while (false);
  RenameMap.clear();

  // For each referenced group register (which must be a SuperReg or
  // a subregister of SuperReg), find the corresponding subregister
  // of NewSuperReg and make sure it is free to be renamed.
  for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
    unsigned Reg = Regs[i];
    unsigned NewReg = 0;
    if (Reg == SuperReg) {
      NewReg = NewSuperReg;
    } else {
      unsigned NewSubRegIdx = TRI->getSubRegIndex(SuperReg, Reg);
      if (NewSubRegIdx != 0)
        NewReg = TRI->getSubReg(NewSuperReg, NewSubRegIdx);
    }

    LLVM_DEBUG(dbgs() << " " << printReg(NewReg, TRI))do { } while (false);

    // Check if Reg can be renamed to NewReg.
    if (!RenameRegisterMap[Reg].test(NewReg)) {
      LLVM_DEBUG(dbgs() << "(no rename)")do { } while (false);
      goto next_super_reg;
    }

    // If NewReg is dead and NewReg's most recent def is not before
    // Regs's kill, it's safe to replace Reg with NewReg. We
    // must also check all aliases of NewReg, because we can't define a
    // register when any sub or super is already live.
    if (State->IsLive(NewReg) || (KillIndices[Reg] > DefIndices[NewReg])) {
      LLVM_DEBUG(dbgs() << "(live)")do { } while (false);
      goto next_super_reg;
    } else {
      bool found = false;
      for (MCRegAliasIterator AI(NewReg, TRI, false); AI.isValid(); ++AI) {
        unsigned AliasReg = *AI;
        if (State->IsLive(AliasReg) ||
            (KillIndices[Reg] > DefIndices[AliasReg])) {
          LLVM_DEBUG(dbgs()do { } while (false)
                     << "(alias " << printReg(AliasReg, TRI) << " live)")do { } while (false);
          found = true;
          break;
        }
      }
      if (found)
        goto next_super_reg;
    }

    // We cannot rename 'Reg' to 'NewReg' if one of the uses of 'Reg' also
    // defines 'NewReg' via an early-clobber operand.
    for (const auto &Q : make_range(RegRefs.equal_range(Reg))) {
      MachineInstr *UseMI = Q.second.Operand->getParent();
      int Idx = UseMI->findRegisterDefOperandIdx(NewReg, false, true, TRI);
      if (Idx == -1)
        continue;

      if (UseMI->getOperand(Idx).isEarlyClobber()) {
        LLVM_DEBUG(dbgs() << "(ec)")do { } while (false);
        goto next_super_reg;
      }
    }

    // Also, we cannot rename 'Reg' to 'NewReg' if the instruction defining
    // 'Reg' is an early-clobber define and that instruction also uses
    // 'NewReg'.
    for (const auto &Q : make_range(RegRefs.equal_range(Reg))) {
      if (!Q.second.Operand->isDef() || !Q.second.Operand->isEarlyClobber())
        continue;

      MachineInstr *DefMI = Q.second.Operand->getParent();
      if (DefMI->readsRegister(NewReg, TRI)) {
        LLVM_DEBUG(dbgs() << "(ec)")do { } while (false);
        goto next_super_reg;
      }
    }

    // Record that 'Reg' can be renamed to 'NewReg'.
    RenameMap.insert(std::pair<unsigned, unsigned>(Reg, NewReg));
  }

  // If we fall-out here, then every register in the group can be
  // renamed, as recorded in RenameMap.
  RenameOrder.erase(SuperRC);
  RenameOrder.insert(RenameOrderType::value_type(SuperRC, R));
  LLVM_DEBUG(dbgs() << "]\n")do { } while (false);
  return true;

next_super_reg:
  LLVM_DEBUG(dbgs() << ']')do { } while (false);
} while (R != EndR);

LLVM_DEBUG(dbgs() << '\n')do { } while (false);

// No registers are free and available!
return false;
741}

743/// BreakAntiDependencies - Identifiy anti-dependencies within the
744/// ScheduleDAG and break them by renaming registers.
745unsigned AggressiveAntiDepBreaker::BreakAntiDependencies(
                            const std::vector<SUnit> &SUnits,
                            MachineBasicBlock::iterator Begin,
                            MachineBasicBlock::iterator End,
                            unsigned InsertPosIndex,
                            DbgValueVector &DbgValues) {
std::vector<unsigned> &KillIndices = State->GetKillIndices();
std::vector<unsigned> &DefIndices = State->GetDefIndices();
std::multimap<unsigned, AggressiveAntiDepState::RegisterReference>&
  RegRefs = State->GetRegRefs();

// The code below assumes that there is at least one instruction,
// so just duck out immediately if the block is empty.
if (SUnits.empty()) return 0;
1
Assuming the condition is false→
2
←
Taking false branch→

// For each regclass the next register to use for renaming.
RenameOrderType RenameOrder;

// ...need a map from MI to SUnit.
std::map<MachineInstr *, const SUnit *> MISUnitMap;
for (unsigned i = 0, e = SUnits.size(); i != e; ++i) {
3
←
Assuming 'i' is equal to 'e'→
4
←
Loop condition is false. Execution continues on line 774→
  const SUnit *SU = &SUnits[i];
  MISUnitMap.insert(std::pair<MachineInstr *, const SUnit *>(SU->getInstr(),
                                                             SU));
}

// Track progress along the critical path through the SUnit graph as
// we walk the instructions. This is needed for regclasses that only
// break critical-path anti-dependencies.
const SUnit *CriticalPathSU = nullptr;
5
←
'CriticalPathSU' initialized to a null pointer value→
MachineInstr *CriticalPathMI = nullptr;
if (CriticalPathSet.any()) {
6
←
Calling 'BitVector::any'→
18
←
Returning from 'BitVector::any'→
19
←
Taking true branch→
  for (unsigned i = 0, e = SUnits.size(); i != e; ++i) {
20
←
Assuming 'i' is equal to 'e'→
21
←
Loop condition is false. Execution continues on line 785→
    const SUnit *SU = &SUnits[i];
    if (!CriticalPathSU ||
        ((SU->getDepth() + SU->Latency) >
         (CriticalPathSU->getDepth() + CriticalPathSU->Latency))) {
      CriticalPathSU = SU;
    }
  }
  assert(CriticalPathSU && "Failed to find SUnit critical path")(static_cast<void> (0));
  CriticalPathMI = CriticalPathSU->getInstr();
22
←
Called C++ object pointer is null
}

789#ifndef NDEBUG1
LLVM_DEBUG(dbgs() << "\n===== Aggressive anti-dependency breaking\n")do { } while (false);
LLVM_DEBUG(dbgs() << "Available regs:")do { } while (false);
for (unsigned Reg = 0; Reg < TRI->getNumRegs(); ++Reg) {
  if (!State->IsLive(Reg))
    LLVM_DEBUG(dbgs() << " " << printReg(Reg, TRI))do { } while (false);
}
LLVM_DEBUG(dbgs() << '\n')do { } while (false);
797#endif

BitVector RegAliases(TRI->getNumRegs());

// Attempt to break anti-dependence edges. Walk the instructions
// from the bottom up, tracking information about liveness as we go
// to help determine which registers are available.
unsigned Broken = 0;
unsigned Count = InsertPosIndex - 1;
for (MachineBasicBlock::iterator I = End, E = Begin;
     I != E; --Count) {
  MachineInstr &MI = *--I;

  if (MI.isDebugInstr())
    continue;

  LLVM_DEBUG(dbgs() << "Anti: ")do { } while (false);
  LLVM_DEBUG(MI.dump())do { } while (false);

  std::set<unsigned> PassthruRegs;
  GetPassthruRegs(MI, PassthruRegs);

  // Process the defs in MI...
  PrescanInstruction(MI, Count, PassthruRegs);

  // The dependence edges that represent anti- and output-
  // dependencies that are candidates for breaking.
  std::vector<const SDep *> Edges;
  const SUnit *PathSU = MISUnitMap[&MI];
  AntiDepEdges(PathSU, Edges);

  // If MI is not on the critical path, then we don't rename
  // registers in the CriticalPathSet.
  BitVector *ExcludeRegs = nullptr;
  if (&MI == CriticalPathMI) {
    CriticalPathSU = CriticalPathStep(CriticalPathSU);
    CriticalPathMI = (CriticalPathSU) ? CriticalPathSU->getInstr() : nullptr;
  } else if (CriticalPathSet.any()) {
    ExcludeRegs = &CriticalPathSet;
  }

  // Ignore KILL instructions (they form a group in ScanInstruction
  // but don't cause any anti-dependence breaking themselves)
  if (!MI.isKill()) {
    // Attempt to break each anti-dependency...
    for (unsigned i = 0, e = Edges.size(); i != e; ++i) {
      const SDep *Edge = Edges[i];
      SUnit *NextSU = Edge->getSUnit();

      if ((Edge->getKind() != SDep::Anti) &&
          (Edge->getKind() != SDep::Output)) continue;

      unsigned AntiDepReg = Edge->getReg();
      LLVM_DEBUG(dbgs() << "\tAntidep reg: " << printReg(AntiDepReg, TRI))do { } while (false);
      assert(AntiDepReg != 0 && "Anti-dependence on reg0?")(static_cast<void> (0));

      if (!MRI.isAllocatable(AntiDepReg)) {
        // Don't break anti-dependencies on non-allocatable registers.
        LLVM_DEBUG(dbgs() << " (non-allocatable)\n")do { } while (false);
        continue;
      } else if (ExcludeRegs && ExcludeRegs->test(AntiDepReg)) {
        // Don't break anti-dependencies for critical path registers
        // if not on the critical path
        LLVM_DEBUG(dbgs() << " (not critical-path)\n")do { } while (false);
        continue;
      } else if (PassthruRegs.count(AntiDepReg) != 0) {
        // If the anti-dep register liveness "passes-thru", then
        // don't try to change it. It will be changed along with
        // the use if required to break an earlier antidep.
        LLVM_DEBUG(dbgs() << " (passthru)\n")do { } while (false);
        continue;
      } else {
        // No anti-dep breaking for implicit deps
        MachineOperand *AntiDepOp = MI.findRegisterDefOperand(AntiDepReg);
        assert(AntiDepOp && "Can't find index for defined register operand")(static_cast<void> (0));
        if (!AntiDepOp || AntiDepOp->isImplicit()) {
          LLVM_DEBUG(dbgs() << " (implicit)\n")do { } while (false);
          continue;
        }

        // If the SUnit has other dependencies on the SUnit that
        // it anti-depends on, don't bother breaking the
        // anti-dependency since those edges would prevent such
        // units from being scheduled past each other
        // regardless.
        //
        // Also, if there are dependencies on other SUnits with the
        // same register as the anti-dependency, don't attempt to
        // break it.
        for (const SDep &Pred : PathSU->Preds) {
          if (Pred.getSUnit() == NextSU ? (Pred.getKind() != SDep::Anti ||
                                           Pred.getReg() != AntiDepReg)
                                        : (Pred.getKind() == SDep::Data &&
                                           Pred.getReg() == AntiDepReg)) {
            AntiDepReg = 0;
            break;
          }
        }
        for (const SDep &Pred : PathSU->Preds) {
          if ((Pred.getSUnit() == NextSU) && (Pred.getKind() != SDep::Anti) &&
              (Pred.getKind() != SDep::Output)) {
            LLVM_DEBUG(dbgs() << " (real dependency)\n")do { } while (false);
            AntiDepReg = 0;
            break;
          } else if ((Pred.getSUnit() != NextSU) &&
                     (Pred.getKind() == SDep::Data) &&
                     (Pred.getReg() == AntiDepReg)) {
            LLVM_DEBUG(dbgs() << " (other dependency)\n")do { } while (false);
            AntiDepReg = 0;
            break;
          }
        }

        if (AntiDepReg == 0) continue;

        // If the definition of the anti-dependency register does not start
        // a new live range, bail out. This can happen if the anti-dep
        // register is a sub-register of another register whose live range
        // spans over PathSU. In such case, PathSU defines only a part of
        // the larger register.
        RegAliases.reset();
        for (MCRegAliasIterator AI(AntiDepReg, TRI, true); AI.isValid(); ++AI)
          RegAliases.set(*AI);
        for (SDep S : PathSU->Succs) {
          SDep::Kind K = S.getKind();
          if (K != SDep::Data && K != SDep::Output && K != SDep::Anti)
            continue;
          unsigned R = S.getReg();
          if (!RegAliases[R])
            continue;
          if (R == AntiDepReg || TRI->isSubRegister(AntiDepReg, R))
            continue;
          AntiDepReg = 0;
          break;
        }

        if (AntiDepReg == 0) continue;
      }

      assert(AntiDepReg != 0)(static_cast<void> (0));
      if (AntiDepReg == 0) continue;

      // Determine AntiDepReg's register group.
      const unsigned GroupIndex = State->GetGroup(AntiDepReg);
      if (GroupIndex == 0) {
        LLVM_DEBUG(dbgs() << " (zero group)\n")do { } while (false);
        continue;
      }

      LLVM_DEBUG(dbgs() << '\n')do { } while (false);

      // Look for a suitable register to use to break the anti-dependence.
      std::map<unsigned, unsigned> RenameMap;
      if (FindSuitableFreeRegisters(GroupIndex, RenameOrder, RenameMap)) {
        LLVM_DEBUG(dbgs() << "\tBreaking anti-dependence edge on "do { } while (false)
                          << printReg(AntiDepReg, TRI) << ":")do { } while (false);

        // Handle each group register...
        for (const auto &P : RenameMap) {
          unsigned CurrReg = P.first;
          unsigned NewReg = P.second;

          LLVM_DEBUG(dbgs() << " " << printReg(CurrReg, TRI) << "->"do { } while (false)
                            << printReg(NewReg, TRI) << "("do { } while (false)
                            << RegRefs.count(CurrReg) << " refs)")do { } while (false);

          // Update the references to the old register CurrReg to
          // refer to the new register NewReg.
          for (const auto &Q : make_range(RegRefs.equal_range(CurrReg))) {
            Q.second.Operand->setReg(NewReg);
            // If the SU for the instruction being updated has debug
            // information related to the anti-dependency register, make
            // sure to update that as well.
            const SUnit *SU = MISUnitMap[Q.second.Operand->getParent()];
            if (!SU) continue;
            UpdateDbgValues(DbgValues, Q.second.Operand->getParent(),
                            AntiDepReg, NewReg);
          }

          // We just went back in time and modified history; the
          // liveness information for CurrReg is now inconsistent. Set
          // the state as if it were dead.
          State->UnionGroups(NewReg, 0);
          RegRefs.erase(NewReg);
          DefIndices[NewReg] = DefIndices[CurrReg];
          KillIndices[NewReg] = KillIndices[CurrReg];

          State->UnionGroups(CurrReg, 0);
          RegRefs.erase(CurrReg);
          DefIndices[CurrReg] = KillIndices[CurrReg];
          KillIndices[CurrReg] = ~0u;
          assert(((KillIndices[CurrReg] == ~0u) !=(static_cast<void> (0))
                  (DefIndices[CurrReg] == ~0u)) &&(static_cast<void> (0))
                 "Kill and Def maps aren't consistent for AntiDepReg!")(static_cast<void> (0));
        }

        ++Broken;
        LLVM_DEBUG(dbgs() << '\n')do { } while (false);
      }
    }
  }

  ScanInstruction(MI, Count);
}

return Broken;
1003}

1005AntiDepBreaker *llvm::createAggressiveAntiDepBreaker(
  MachineFunction &MFi, const RegisterClassInfo &RCI,
  TargetSubtargetInfo::RegClassVector &CriticalPathRCs) {
return new AggressiveAntiDepBreaker(MFi, RCI, CriticalPathRCs);
1009}

←

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/ADT/BitVector.h

→

1//===- llvm/ADT/BitVector.h - Bit vectors -----------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the BitVector class.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_ADT_BITVECTOR_H
14#define LLVM_ADT_BITVECTOR_H

16#include "llvm/ADT/ArrayRef.h"
17#include "llvm/ADT/DenseMapInfo.h"
18#include "llvm/ADT/iterator_range.h"
19#include "llvm/Support/MathExtras.h"
20#include <algorithm>
21#include <cassert>
22#include <climits>
23#include <cstdint>
24#include <cstdlib>
25#include <cstring>
26#include <utility>

28namespace llvm {

30/// ForwardIterator for the bits that are set.
31/// Iterators get invalidated when resize / reserve is called.
32template <typename BitVectorT> class const_set_bits_iterator_impl {
const BitVectorT &Parent;
int Current = 0;

void advance() {
  assert(Current != -1 && "Trying to advance past end.")(static_cast<void> (0));
  Current = Parent.find_next(Current);
}

41public:
const_set_bits_iterator_impl(const BitVectorT &Parent, int Current)
    : Parent(Parent), Current(Current) {}
explicit const_set_bits_iterator_impl(const BitVectorT &Parent)
    : const_set_bits_iterator_impl(Parent, Parent.find_first()) {}
const_set_bits_iterator_impl(const const_set_bits_iterator_impl &) = default;

const_set_bits_iterator_impl operator++(int) {
  auto Prev = *this;
  advance();
  return Prev;
}

const_set_bits_iterator_impl &operator++() {
  advance();
  return *this;
}

unsigned operator*() const { return Current; }

bool operator==(const const_set_bits_iterator_impl &Other) const {
  assert(&Parent == &Other.Parent &&(static_cast<void> (0))
         "Comparing iterators from different BitVectors")(static_cast<void> (0));
  return Current == Other.Current;
}

bool operator!=(const const_set_bits_iterator_impl &Other) const {
  assert(&Parent == &Other.Parent &&(static_cast<void> (0))
         "Comparing iterators from different BitVectors")(static_cast<void> (0));
  return Current != Other.Current;
}
72};

74class BitVector {
typedef uintptr_t BitWord;

enum { BITWORD_SIZE = (unsigned)sizeof(BitWord) * CHAR_BIT8 };

static_assert(BITWORD_SIZE == 64 || BITWORD_SIZE == 32,
              "Unsupported word size");

using Storage = SmallVector<BitWord>;

Storage Bits;  // Actual bits.
unsigned Size; // Size of bitvector in bits.

87public:
using size_type = unsigned;

// Encapsulation of a single bit.
class reference {

  BitWord *WordRef;
  unsigned BitPos;

public:
  reference(BitVector &b, unsigned Idx) {
    WordRef = &b.Bits[Idx / BITWORD_SIZE];
    BitPos = Idx % BITWORD_SIZE;
  }

  reference() = delete;
  reference(const reference&) = default;

  reference &operator=(reference t) {
    *this = bool(t);
    return *this;
  }

  reference& operator=(bool t) {
    if (t)
      *WordRef |= BitWord(1) << BitPos;
    else
      *WordRef &= ~(BitWord(1) << BitPos);
    return *this;
  }

  operator bool() const {
    return ((*WordRef) & (BitWord(1) << BitPos)) != 0;
  }
};

typedef const_set_bits_iterator_impl<BitVector> const_set_bits_iterator;
typedef const_set_bits_iterator set_iterator;

const_set_bits_iterator set_bits_begin() const {
  return const_set_bits_iterator(*this);
}
const_set_bits_iterator set_bits_end() const {
  return const_set_bits_iterator(*this, -1);
}
iterator_range<const_set_bits_iterator> set_bits() const {
  return make_range(set_bits_begin(), set_bits_end());
}

/// BitVector default ctor - Creates an empty bitvector.
BitVector() : Size(0) {}

/// BitVector ctor - Creates a bitvector of specified number of bits. All
/// bits are initialized to the specified value.
explicit BitVector(unsigned s, bool t = false)
    : Bits(NumBitWords(s), 0 - (BitWord)t), Size(s) {
  if (t)
    clear_unused_bits();
}

/// empty - Tests whether there are no bits in this bitvector.
bool empty() const { return Size == 0; }

/// size - Returns the number of bits in this bitvector.
size_type size() const { return Size; }

/// count - Returns the number of bits which are set.
size_type count() const {
  unsigned NumBits = 0;
  for (auto Bit : Bits)
    NumBits += countPopulation(Bit);
  return NumBits;
}

/// any - Returns true if any bit is set.
bool any() const {
  return any_of(Bits, [](BitWord Bit) { return Bit != 0; });
7
←
Calling 'any_of<const llvm::SmallVector<unsigned long, 6> &, (lambda at /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/ADT/BitVector.h:163:25)>'→
16
←
Returning from 'any_of<const llvm::SmallVector<unsigned long, 6> &, (lambda at /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/ADT/BitVector.h:163:25)>'→
17
←
Returning the value 1, which participates in a condition later→
}

/// all - Returns true if all bits are set.
bool all() const {
  for (unsigned i = 0; i < Size / BITWORD_SIZE; ++i)
    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] == (BitWord(1) << Remainder) - 1;

  return true;
}

/// none - Returns true if none of the bits are set.
bool none() const {
  return !any();
}

/// 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)(static_cast<void> (0));
  if (Begin == End)
    return -1;

  unsigned FirstWord = Begin / BITWORD_SIZE;
  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;
      Copy &= maskTrailingZeros<BitWord>(FirstBit);
    }

    if (i == LastWord) {
      unsigned LastBit = (End - 1) % BITWORD_SIZE;
      Copy &= maskTrailingOnes<BitWord>(LastBit + 1);
    }
    if (Copy != 0)
      return i * BITWORD_SIZE + countTrailingZeros(Copy);
  }
  return -1;
}

/// find_last_in - Returns the index of the last set bit in the range
/// [Begin, End).  Returns -1 if all bits in the range are unset.
int find_last_in(unsigned Begin, unsigned End) const {
  assert(Begin <= End && End <= Size)(static_cast<void> (0));
  if (Begin == End)
    return -1;

  unsigned LastWord = (End - 1) / BITWORD_SIZE;
  unsigned FirstWord = Begin / BITWORD_SIZE;

  for (unsigned i = LastWord + 1; i >= FirstWord + 1; --i) {
    unsigned CurrentWord = i - 1;

    BitWord Copy = Bits[CurrentWord];
    if (CurrentWord == LastWord) {
      unsigned LastBit = (End - 1) % BITWORD_SIZE;
      Copy &= maskTrailingOnes<BitWord>(LastBit + 1);
    }

    if (CurrentWord == FirstWord) {
      unsigned FirstBit = Begin % BITWORD_SIZE;
      Copy &= maskTrailingZeros<BitWord>(FirstBit);
    }

    if (Copy != 0)
      return (CurrentWord + 1) * BITWORD_SIZE - countLeadingZeros(Copy) - 1;
  }

  return -1;
}

/// 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 {
  return find_first_in(Begin, End, /* Set = */ false);
}

/// find_last_unset_in - Returns the index of the last unset bit in the
/// range [Begin, End).  Returns -1 if all bits in the range are set.
int find_last_unset_in(unsigned Begin, unsigned End) const {
  assert(Begin <= End && End <= Size)(static_cast<void> (0));
  if (Begin == End)
    return -1;

  unsigned LastWord = (End - 1) / BITWORD_SIZE;
  unsigned FirstWord = Begin / BITWORD_SIZE;

  for (unsigned i = LastWord + 1; i >= FirstWord + 1; --i) {
    unsigned CurrentWord = i - 1;

    BitWord Copy = Bits[CurrentWord];
    if (CurrentWord == LastWord) {
      unsigned LastBit = (End - 1) % BITWORD_SIZE;
      Copy |= maskTrailingZeros<BitWord>(LastBit + 1);
    }

    if (CurrentWord == FirstWord) {
      unsigned FirstBit = Begin % BITWORD_SIZE;
      Copy |= maskTrailingOnes<BitWord>(FirstBit);
    }

    if (Copy != ~BitWord(0)) {
      unsigned Result =
          (CurrentWord + 1) * BITWORD_SIZE - countLeadingOnes(Copy) - 1;
      return Result < Size ? Result : -1;
    }
  }
  return -1;
}

/// find_first - Returns the index of the first set bit, -1 if none
/// of the bits are set.
int find_first() const { return find_first_in(0, Size); }

/// find_last - Returns the index of the last set bit, -1 if none of the bits
/// are set.
int find_last() const { return find_last_in(0, Size); }

/// find_next - Returns the index of the next set bit following the
/// "Prev" bit. Returns -1 if the next set bit is not found.
int find_next(unsigned Prev) const { return find_first_in(Prev + 1, Size); }

/// find_prev - Returns the index of the first set bit that precedes the
/// the bit at \p PriorTo.  Returns -1 if all previous bits are unset.
int find_prev(unsigned PriorTo) const { return find_last_in(0, PriorTo); }

/// find_first_unset - Returns the index of the first unset bit, -1 if all
/// of the bits are set.
int find_first_unset() const { return find_first_unset_in(0, Size); }

/// find_next_unset - Returns the index of the next unset bit following the
/// "Prev" bit.  Returns -1 if all remaining bits are set.
int find_next_unset(unsigned Prev) const {
  return find_first_unset_in(Prev + 1, Size);
}

/// find_last_unset - Returns the index of the last unset bit, -1 if all of
/// the bits are set.
int find_last_unset() const { return find_last_unset_in(0, Size); }

/// find_prev_unset - Returns the index of the first unset bit that precedes
/// the bit at \p PriorTo.  Returns -1 if all previous bits are set.
int find_prev_unset(unsigned PriorTo) {
  return find_last_unset_in(0, PriorTo);
}

/// clear - Removes all bits from the bitvector.
void clear() {
  Size = 0;
  Bits.clear();
}

/// resize - Grow or shrink the bitvector.
void resize(unsigned N, bool t = false) {
  set_unused_bits(t);
  Size = N;
  Bits.resize(NumBitWords(N), 0 - BitWord(t));
  clear_unused_bits();
}

void reserve(unsigned N) { Bits.reserve(NumBitWords(N)); }

// Set, reset, flip
BitVector &set() {
  init_words(true);
  clear_unused_bits();
  return *this;
}

BitVector &set(unsigned Idx) {
  assert(Idx < Size && "access in bound")(static_cast<void> (0));
  Bits[Idx / BITWORD_SIZE] |= BitWord(1) << (Idx % BITWORD_SIZE);
  return *this;
}

/// set - Efficiently set a range of bits in [I, E)
BitVector &set(unsigned I, unsigned E) {
  assert(I <= E && "Attempted to set backwards range!")(static_cast<void> (0));
  assert(E <= size() && "Attempted to set out-of-bounds range!")(static_cast<void> (0));

  if (I == E) return *this;

  if (I / BITWORD_SIZE == E / 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 = ~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] = ~BitWord(0);

  BitWord PostfixMask = (BitWord(1) << (E % BITWORD_SIZE)) - 1;
  if (I < E)
    Bits[I / BITWORD_SIZE] |= PostfixMask;

  return *this;
}

BitVector &reset() {
  init_words(false);
  return *this;
}

BitVector &reset(unsigned Idx) {
  Bits[Idx / BITWORD_SIZE] &= ~(BitWord(1) << (Idx % BITWORD_SIZE));
  return *this;
}

/// reset - Efficiently reset a range of bits in [I, E)
BitVector &reset(unsigned I, unsigned E) {
  assert(I <= E && "Attempted to reset backwards range!")(static_cast<void> (0));
  assert(E <= size() && "Attempted to reset out-of-bounds range!")(static_cast<void> (0));

  if (I == E) return *this;

  if (I / BITWORD_SIZE == E / 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 = ~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] = BitWord(0);

  BitWord PostfixMask = (BitWord(1) << (E % BITWORD_SIZE)) - 1;
  if (I < E)
    Bits[I / BITWORD_SIZE] &= ~PostfixMask;

  return *this;
}

BitVector &flip() {
  for (auto &Bit : Bits)
    Bit = ~Bit;
  clear_unused_bits();
  return *this;
}

BitVector &flip(unsigned Idx) {
  Bits[Idx / BITWORD_SIZE] ^= BitWord(1) << (Idx % BITWORD_SIZE);
  return *this;
}

// Indexing.
reference operator[](unsigned Idx) {
  assert (Idx < Size && "Out-of-bounds Bit access.")(static_cast<void> (0));
  return reference(*this, Idx);
}

bool operator[](unsigned Idx) const {
  assert (Idx < Size && "Out-of-bounds Bit access.")(static_cast<void> (0));
  BitWord Mask = BitWord(1) << (Idx % BITWORD_SIZE);
  return (Bits[Idx / BITWORD_SIZE] & Mask) != 0;
}

bool test(unsigned Idx) const {
  return (*this)[Idx];
}

// Push single bit to end of vector.
void push_back(bool Val) {
  unsigned OldSize = Size;
  unsigned NewSize = Size + 1;

  // Resize, which will insert zeros.
  // If we already fit then the unused bits will be already zero.
  if (NewSize > getBitCapacity())
    resize(NewSize, false);
  else
    Size = NewSize;

  // If true, set single bit.
  if (Val)
    set(OldSize);
}

/// Test if any common bits are set.
bool anyCommon(const BitVector &RHS) const {
  unsigned ThisWords = Bits.size();
  unsigned RHSWords = RHS.Bits.size();
  for (unsigned i = 0, e = std::min(ThisWords, RHSWords); i != e; ++i)
    if (Bits[i] & RHS.Bits[i])
      return true;
  return false;
}

// Comparison operators.
bool operator==(const BitVector &RHS) const {
  if (size() != RHS.size())
    return false;
  unsigned NumWords = Bits.size();
  return std::equal(Bits.begin(), Bits.begin() + NumWords, RHS.Bits.begin());
}

bool operator!=(const BitVector &RHS) const { return !(*this == RHS); }

/// Intersection, union, disjoint union.
BitVector &operator&=(const BitVector &RHS) {
  unsigned ThisWords = Bits.size();
  unsigned RHSWords = RHS.Bits.size();
  unsigned i;
  for (i = 0; i != std::min(ThisWords, RHSWords); ++i)
    Bits[i] &= RHS.Bits[i];

  // Any bits that are just in this bitvector become zero, because they aren't
  // in the RHS bit vector.  Any words only in RHS are ignored because they
  // are already zero in the LHS.
  for (; i != ThisWords; ++i)
    Bits[i] = 0;

  return *this;
}

/// reset - Reset bits that are set in RHS. Same as *this &= ~RHS.
BitVector &reset(const BitVector &RHS) {
  unsigned ThisWords = Bits.size();
  unsigned RHSWords = RHS.Bits.size();
  for (unsigned i = 0; i != std::min(ThisWords, RHSWords); ++i)
    Bits[i] &= ~RHS.Bits[i];
  return *this;
}

/// test - Check if (This - RHS) is zero.
/// This is the same as reset(RHS) and any().
bool test(const BitVector &RHS) const {
  unsigned ThisWords = Bits.size();
  unsigned RHSWords = RHS.Bits.size();
  unsigned i;
  for (i = 0; i != std::min(ThisWords, RHSWords); ++i)
    if ((Bits[i] & ~RHS.Bits[i]) != 0)
      return true;

  for (; i != ThisWords ; ++i)
    if (Bits[i] != 0)
      return true;

  return false;
}

template <class F, class... ArgTys>
static BitVector &apply(F &&f, BitVector &Out, BitVector const &Arg,
                        ArgTys const &...Args) {
  assert(llvm::all_of((static_cast<void> (0))
             std::initializer_list<unsigned>{Args.size()...},(static_cast<void> (0))
             [&Arg](auto const &BV) { return Arg.size() == BV; }) &&(static_cast<void> (0))
         "consistent sizes")(static_cast<void> (0));
  Out.resize(Arg.size());
  for (size_type I = 0, E = Arg.Bits.size(); I != E; ++I)
    Out.Bits[I] = f(Arg.Bits[I], Args.Bits[I]...);
  Out.clear_unused_bits();
  return Out;
}

BitVector &operator|=(const BitVector &RHS) {
  if (size() < RHS.size())
    resize(RHS.size());
  for (size_type I = 0, E = RHS.Bits.size(); I != E; ++I)
    Bits[I] |= RHS.Bits[I];
  return *this;
}

BitVector &operator^=(const BitVector &RHS) {
  if (size() < RHS.size())
    resize(RHS.size());
  for (size_type I = 0, E = RHS.Bits.size(); I != E; ++I)
    Bits[I] ^= RHS.Bits[I];
  return *this;
}

BitVector &operator>>=(unsigned N) {
  assert(N <= Size)(static_cast<void> (0));
  if (LLVM_UNLIKELY(empty() || N == 0)__builtin_expect((bool)(empty() || N == 0), false))
    return *this;

  unsigned NumWords = Bits.size();
  assert(NumWords >= 1)(static_cast<void> (0));

  wordShr(N / BITWORD_SIZE);

  unsigned BitDistance = N % BITWORD_SIZE;
  if (BitDistance == 0)
    return *this;

  // When the shift size is not a multiple of the word size, then we have
  // a tricky situation where each word in succession needs to extract some
  // of the bits from the next word and or them into this word while
  // shifting this word to make room for the new bits.  This has to be done
  // for every word in the array.

  // Since we're shifting each word right, some bits will fall off the end
  // of each word to the right, and empty space will be created on the left.
  // The final word in the array will lose bits permanently, so starting at
  // the beginning, work forwards shifting each word to the right, and
  // OR'ing in the bits from the end of the next word to the beginning of
  // the current word.

  // Example:
  //   Starting with {0xAABBCCDD, 0xEEFF0011, 0x22334455} and shifting right
  //   by 4 bits.
  // Step 1: Word[0] >>= 4           ; 0x0ABBCCDD
  // Step 2: Word[0] |= 0x10000000   ; 0x1ABBCCDD
  // Step 3: Word[1] >>= 4           ; 0x0EEFF001
  // Step 4: Word[1] |= 0x50000000   ; 0x5EEFF001
  // Step 5: Word[2] >>= 4           ; 0x02334455
  // Result: { 0x1ABBCCDD, 0x5EEFF001, 0x02334455 }
  const BitWord Mask = maskTrailingOnes<BitWord>(BitDistance);
  const unsigned LSH = BITWORD_SIZE - BitDistance;

  for (unsigned I = 0; I < NumWords - 1; ++I) {
    Bits[I] >>= BitDistance;
    Bits[I] |= (Bits[I + 1] & Mask) << LSH;
  }

  Bits[NumWords - 1] >>= BitDistance;

  return *this;
}

BitVector &operator<<=(unsigned N) {
  assert(N <= Size)(static_cast<void> (0));
  if (LLVM_UNLIKELY(empty() || N == 0)__builtin_expect((bool)(empty() || N == 0), false))
    return *this;

  unsigned NumWords = Bits.size();
  assert(NumWords >= 1)(static_cast<void> (0));

  wordShl(N / BITWORD_SIZE);

  unsigned BitDistance = N % BITWORD_SIZE;
  if (BitDistance == 0)
    return *this;

  // When the shift size is not a multiple of the word size, then we have
  // a tricky situation where each word in succession needs to extract some
  // of the bits from the previous word and or them into this word while
  // shifting this word to make room for the new bits.  This has to be done
  // for every word in the array.  This is similar to the algorithm outlined
  // in operator>>=, but backwards.

  // Since we're shifting each word left, some bits will fall off the end
  // of each word to the left, and empty space will be created on the right.
  // The first word in the array will lose bits permanently, so starting at
  // the end, work backwards shifting each word to the left, and OR'ing
  // in the bits from the end of the next word to the beginning of the
  // current word.

  // Example:
  //   Starting with {0xAABBCCDD, 0xEEFF0011, 0x22334455} and shifting left
  //   by 4 bits.
  // Step 1: Word[2] <<= 4           ; 0x23344550
  // Step 2: Word[2] |= 0x0000000E   ; 0x2334455E
  // Step 3: Word[1] <<= 4           ; 0xEFF00110
  // Step 4: Word[1] |= 0x0000000A   ; 0xEFF0011A
  // Step 5: Word[0] <<= 4           ; 0xABBCCDD0
  // Result: { 0xABBCCDD0, 0xEFF0011A, 0x2334455E }
  const BitWord Mask = maskLeadingOnes<BitWord>(BitDistance);
  const unsigned RSH = BITWORD_SIZE - BitDistance;

  for (int I = NumWords - 1; I > 0; --I) {
    Bits[I] <<= BitDistance;
    Bits[I] |= (Bits[I - 1] & Mask) >> RSH;
  }
  Bits[0] <<= BitDistance;
  clear_unused_bits();

  return *this;
}

void swap(BitVector &RHS) {
  std::swap(Bits, RHS.Bits);
  std::swap(Size, RHS.Size);
}

void invalid() {
  assert(!Size && Bits.empty())(static_cast<void> (0));
  Size = (unsigned)-1;
}
bool isInvalid() const { return Size == (unsigned)-1; }

ArrayRef<BitWord> getData() const { return {&Bits[0], Bits.size()}; }

//===--------------------------------------------------------------------===//
// Portable bit mask operations.
//===--------------------------------------------------------------------===//
//
// These methods all operate on arrays of uint32_t, each holding 32 bits. The
// fixed word size makes it easier to work with literal bit vector constants
// in portable code.
//
// The LSB in each word is the lowest numbered bit.  The size of a portable
// bit mask is always a whole multiple of 32 bits.  If no bit mask size is
// given, the bit mask is assumed to cover the entire BitVector.

/// setBitsInMask - Add '1' bits from Mask to this vector. Don't resize.
/// This computes "*this |= Mask".
void setBitsInMask(const uint32_t *Mask, unsigned MaskWords = ~0u) {
  applyMask<true, false>(Mask, MaskWords);
}

/// clearBitsInMask - Clear any bits in this vector that are set in Mask.
/// Don't resize. This computes "*this &= ~Mask".
void clearBitsInMask(const uint32_t *Mask, unsigned MaskWords = ~0u) {
  applyMask<false, false>(Mask, MaskWords);
}

/// setBitsNotInMask - Add a bit to this vector for every '0' bit in Mask.
/// Don't resize.  This computes "*this |= ~Mask".
void setBitsNotInMask(const uint32_t *Mask, unsigned MaskWords = ~0u) {
  applyMask<true, true>(Mask, MaskWords);
}

/// clearBitsNotInMask - Clear a bit in this vector for every '0' bit in Mask.
/// Don't resize.  This computes "*this &= Mask".
void clearBitsNotInMask(const uint32_t *Mask, unsigned MaskWords = ~0u) {
  applyMask<false, true>(Mask, MaskWords);
}

709private:
/// Perform a logical left shift of \p Count words by moving everything
/// \p Count words to the right in memory.
///
/// While confusing, words are stored from least significant at Bits[0] to
/// most significant at Bits[NumWords-1].  A logical shift left, however,
/// moves the current least significant bit to a higher logical index, and
/// fills the previous least significant bits with 0.  Thus, we actually
/// need to move the bytes of the memory to the right, not to the left.
/// Example:
///   Words = [0xBBBBAAAA, 0xDDDDFFFF, 0x00000000, 0xDDDD0000]
/// represents a BitVector where 0xBBBBAAAA contain the least significant
/// bits.  So if we want to shift the BitVector left by 2 words, we need
/// to turn this into 0x00000000 0x00000000 0xBBBBAAAA 0xDDDDFFFF by using a
/// memmove which moves right, not left.
void wordShl(uint32_t Count) {
  if (Count == 0)
    return;

  uint32_t NumWords = Bits.size();

  // Since we always move Word-sized chunks of data with src and dest both
  // aligned to a word-boundary, we don't need to worry about endianness
  // here.
  std::copy(Bits.begin(), Bits.begin() + NumWords - Count,
            Bits.begin() + Count);
  std::fill(Bits.begin(), Bits.begin() + Count, 0);
  clear_unused_bits();
}

/// Perform a logical right shift of \p Count words by moving those
/// words to the left in memory.  See wordShl for more information.
///
void wordShr(uint32_t Count) {
  if (Count == 0)
    return;

  uint32_t NumWords = Bits.size();

  std::copy(Bits.begin() + Count, Bits.begin() + NumWords, Bits.begin());
  std::fill(Bits.begin() + NumWords - Count, Bits.begin() + NumWords, 0);
}

int next_unset_in_word(int WordIndex, BitWord Word) const {
  unsigned Result = WordIndex * BITWORD_SIZE + countTrailingOnes(Word);
  return Result < size() ? Result : -1;
}

unsigned NumBitWords(unsigned S) const {
  return (S + BITWORD_SIZE-1) / BITWORD_SIZE;
}

// Set the unused bits in the high words.
void set_unused_bits(bool t = true) {
  //  Then set any stray high bits of the last used word.
  if (unsigned ExtraBits = Size % BITWORD_SIZE) {
    BitWord ExtraBitMask = ~BitWord(0) << ExtraBits;
    if (t)
      Bits.back() |= ExtraBitMask;
    else
      Bits.back() &= ~ExtraBitMask;
  }
}

// Clear the unused bits in the high words.
void clear_unused_bits() {
  set_unused_bits(false);
}

void init_words(bool t) {
  std::fill(Bits.begin(), Bits.end(), 0 - (BitWord)t);
}

template<bool AddBits, bool InvertMask>
void applyMask(const uint32_t *Mask, unsigned MaskWords) {
  static_assert(BITWORD_SIZE % 32 == 0, "Unsupported BitWord size.");
  MaskWords = std::min(MaskWords, (size() + 31) / 32);
  const unsigned Scale = BITWORD_SIZE / 32;
  unsigned i;
  for (i = 0; MaskWords >= Scale; ++i, MaskWords -= Scale) {
    BitWord BW = Bits[i];
    // This inner loop should unroll completely when BITWORD_SIZE > 32.
    for (unsigned b = 0; b != BITWORD_SIZE; b += 32) {
      uint32_t M = *Mask++;
      if (InvertMask) M = ~M;
      if (AddBits) BW |=   BitWord(M) << b;
      else         BW &= ~(BitWord(M) << b);
    }
    Bits[i] = BW;
  }
  for (unsigned b = 0; MaskWords; b += 32, --MaskWords) {
    uint32_t M = *Mask++;
    if (InvertMask) M = ~M;
    if (AddBits) Bits[i] |=   BitWord(M) << b;
    else         Bits[i] &= ~(BitWord(M) << b);
  }
  if (AddBits)
    clear_unused_bits();
}

809public:
/// Return the size (in bytes) of the bit vector.
size_type getMemorySize() const { return Bits.size() * sizeof(BitWord); }
size_type getBitCapacity() const { return Bits.size() * BITWORD_SIZE; }
813};

815inline BitVector::size_type capacity_in_bytes(const BitVector &X) {
return X.getMemorySize();
817}

819template <> struct DenseMapInfo<BitVector> {
static inline BitVector getEmptyKey() { return {}; }
static inline BitVector getTombstoneKey() {
  BitVector V;
  V.invalid();
  return V;
}
static unsigned getHashValue(const BitVector &V) {
  return DenseMapInfo<std::pair<BitVector::size_type, 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;
}
835};
836} // end namespace llvm

838namespace std {
/// Implement std::swap in terms of BitVector swap.
840inline void swap(llvm::BitVector &LHS, llvm::BitVector &RHS) { LHS.swap(RHS); }
841} // end namespace std

843#endif // LLVM_ADT_BITVECTOR_H

←

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/ADT/STLExtras.h

→

1//===- llvm/ADT/STLExtras.h - Useful STL related functions ------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains some templates that are useful if you are working with the
10// STL at all.
11//
12// No library is required when using these functions.
13//
14//===----------------------------------------------------------------------===//
15 
16#ifndef LLVM_ADT_STLEXTRAS_H
17#define LLVM_ADT_STLEXTRAS_H
18 
19#include "llvm/ADT/Optional.h"
20#include "llvm/ADT/STLForwardCompat.h"
21#include "llvm/ADT/iterator.h"
22#include "llvm/ADT/iterator_range.h"
23#include "llvm/Config/abi-breaking.h"
24#include "llvm/Support/ErrorHandling.h"
25#include <algorithm>
26#include <cassert>
27#include <cstddef>
28#include <cstdint>
29#include <cstdlib>
30#include <functional>
31#include <initializer_list>
32#include <iterator>
33#include <limits>
34#include <memory>
35#include <tuple>
36#include <type_traits>
37#include <utility>
38 
39#ifdef EXPENSIVE_CHECKS
40#include <random> // for std::mt19937
41#endif
42 
43namespace llvm {
44 
45// Only used by compiler if both template types are the same.  Useful when
46// using SFINAE to test for the existence of member functions.
47template <typename T, T> struct SameType;
48 
49namespace detail {
50 
51template <typename RangeT>
52using IterOfRange = decltype(std::begin(std::declval<RangeT &>()));
53 
54template <typename RangeT>
55using ValueOfRange = typename std::remove_reference<decltype(
56    *std::begin(std::declval<RangeT &>()))>::type;
57 
58} // end namespace detail
59 
60//===----------------------------------------------------------------------===//
61//     Extra additions to <type_traits>
62//===----------------------------------------------------------------------===//
63 
64template <typename T> struct make_const_ptr {
65  using type =
66      typename std::add_pointer<typename std::add_const<T>::type>::type;
67};
68 
69template <typename T> struct make_const_ref {
70  using type = typename std::add_lvalue_reference<
71      typename std::add_const<T>::type>::type;
72};
73 
74namespace detail {
75template <typename...> using void_t = void;
76template <class, template <class...> class Op, class... Args> struct detector {
77  using value_t = std::false_type;
78};
79template <template <class...> class Op, class... Args>
80struct detector<void_t<Op<Args...>>, Op, Args...> {
81  using value_t = std::true_type;
82};
83} // end namespace detail
84 
85/// Detects if a given trait holds for some set of arguments 'Args'.
86/// For example, the given trait could be used to detect if a given type
87/// has a copy assignment operator:
88///   template<class T>
89///   using has_copy_assign_t = decltype(std::declval<T&>()
90///                                                 = std::declval<const T&>());
91///   bool fooHasCopyAssign = is_detected<has_copy_assign_t, FooClass>::value;
92template <template <class...> class Op, class... Args>
93using is_detected = typename detail::detector<void, Op, Args...>::value_t;
94 
95namespace detail {
96template <typename Callable, typename... Args>
97using is_invocable =
98    decltype(std::declval<Callable &>()(std::declval<Args>()...));
99} // namespace detail
100 
101/// Check if a Callable type can be invoked with the given set of arg types.
102template <typename Callable, typename... Args>
103using is_invocable = is_detected<detail::is_invocable, Callable, Args...>;
104 
105/// This class provides various trait information about a callable object.
106///   * To access the number of arguments: Traits::num_args
107///   * To access the type of an argument: Traits::arg_t<Index>
108///   * To access the type of the result:  Traits::result_t
109template <typename T, bool isClass = std::is_class<T>::value>
110struct function_traits : public function_traits<decltype(&T::operator())> {};
111 
112/// Overload for class function types.
113template <typename ClassType, typename ReturnType, typename... Args>
114struct function_traits<ReturnType (ClassType::*)(Args...) const, false> {
115  /// The number of arguments to this function.
116  enum { num_args = sizeof...(Args) };
117 
118  /// The result type of this function.
119  using result_t = ReturnType;
120 
121  /// The type of an argument to this function.
122  template <size_t Index>
123  using arg_t = typename std::tuple_element<Index, std::tuple<Args...>>::type;
124};
125/// Overload for class function types.
126template <typename ClassType, typename ReturnType, typename... Args>
127struct function_traits<ReturnType (ClassType::*)(Args...), false>
128    : function_traits<ReturnType (ClassType::*)(Args...) const> {};
129/// Overload for non-class function types.
130template <typename ReturnType, typename... Args>
131struct function_traits<ReturnType (*)(Args...), false> {
132  /// The number of arguments to this function.
133  enum { num_args = sizeof...(Args) };
134 
135  /// The result type of this function.
136  using result_t = ReturnType;
137 
138  /// The type of an argument to this function.
139  template <size_t i>
140  using arg_t = typename std::tuple_element<i, std::tuple<Args...>>::type;
141};
142/// Overload for non-class function type references.
143template <typename ReturnType, typename... Args>
144struct function_traits<ReturnType (&)(Args...), false>
145    : public function_traits<ReturnType (*)(Args...)> {};
146 
147//===----------------------------------------------------------------------===//
148//     Extra additions to <functional>
149//===----------------------------------------------------------------------===//
150 
151template <class Ty> struct identity {
152  using argument_type = Ty;
153 
154  Ty &operator()(Ty &self) const {
155    return self;
156  }
157  const Ty &operator()(const Ty &self) const {
158    return self;
159  }
160};
161 
162/// An efficient, type-erasing, non-owning reference to a callable. This is
163/// intended for use as the type of a function parameter that is not used
164/// after the function in question returns.
165///
166/// This class does not own the callable, so it is not in general safe to store
167/// a function_ref.
168template<typename Fn> class function_ref;
169 
170template<typename Ret, typename ...Params>
171class function_ref<Ret(Params...)> {
172  Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
173  intptr_t callable;
174 
175  template<typename Callable>
176  static Ret callback_fn(intptr_t callable, Params ...params) {
177    return (*reinterpret_cast<Callable*>(callable))(
178        std::forward<Params>(params)...);
179  }
180 
181public:
182  function_ref() = default;
183  function_ref(std::nullptr_t) {}
184 
185  template <typename Callable>
186  function_ref(
187      Callable &&callable,
188      // This is not the copy-constructor.
189      std::enable_if_t<!std::is_same<remove_cvref_t<Callable>,
190                                     function_ref>::value> * = nullptr,
191      // Functor must be callable and return a suitable type.
192      std::enable_if_t<std::is_void<Ret>::value ||
193                       std::is_convertible<decltype(std::declval<Callable>()(
194                                               std::declval<Params>()...)),
195                                           Ret>::value> * = nullptr)
196      : callback(callback_fn<typename std::remove_reference<Callable>::type>),
197        callable(reinterpret_cast<intptr_t>(&callable)) {}
198 
199  Ret operator()(Params ...params) const {
200    return callback(callable, std::forward<Params>(params)...);
201  }
202 
203  explicit operator bool() const { return callback; }
204};
205 
206//===----------------------------------------------------------------------===//
207//     Extra additions to <iterator>
208//===----------------------------------------------------------------------===//
209 
210namespace adl_detail {
211 
212using std::begin;
213 
214template <typename ContainerTy>
215decltype(auto) adl_begin(ContainerTy &&container) {
216  return begin(std::forward<ContainerTy>(container));
217}
218 
219using std::end;
220 
221template <typename ContainerTy>
222decltype(auto) adl_end(ContainerTy &&container) {
223  return end(std::forward<ContainerTy>(container));
224}
225 
226using std::swap;
227 
228template <typename T>
229void adl_swap(T &&lhs, T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
230                                                       std::declval<T>()))) {
231  swap(std::forward<T>(lhs), std::forward<T>(rhs));
232}
233 
234} // end namespace adl_detail
235 
236template <typename ContainerTy>
237decltype(auto) adl_begin(ContainerTy &&container) {
238  return adl_detail::adl_begin(std::forward<ContainerTy>(container));
239}
240 
241template <typename ContainerTy>
242decltype(auto) adl_end(ContainerTy &&container) {
243  return adl_detail::adl_end(std::forward<ContainerTy>(container));
244}
245 
246template <typename T>
247void adl_swap(T &&lhs, T &&rhs) noexcept(
248    noexcept(adl_detail::adl_swap(std::declval<T>(), std::declval<T>()))) {
249  adl_detail::adl_swap(std::forward<T>(lhs), std::forward<T>(rhs));
250}
251 
252/// Test whether \p RangeOrContainer is empty. Similar to C++17 std::empty.
253template <typename T>
254constexpr bool empty(const T &RangeOrContainer) {
255  return adl_begin(RangeOrContainer) == adl_end(RangeOrContainer);
256}
257 
258/// Returns true if the given container only contains a single element.
259template <typename ContainerTy> bool hasSingleElement(ContainerTy &&C) {
260  auto B = std::begin(C), E = std::end(C);
261  return B != E && std::next(B) == E;
262}
263 
264/// Return a range covering \p RangeOrContainer with the first N elements
265/// excluded.
266template <typename T> auto drop_begin(T &&RangeOrContainer, size_t N = 1) {
267  return make_range(std::next(adl_begin(RangeOrContainer), N),
268                    adl_end(RangeOrContainer));
269}
270 
271// mapped_iterator - This is a simple iterator adapter that causes a function to
272// be applied whenever operator* is invoked on the iterator.
273 
274template <typename ItTy, typename FuncTy,
275          typename FuncReturnTy =
276            decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
277class mapped_iterator
278    : public iterator_adaptor_base<
279             mapped_iterator<ItTy, FuncTy>, ItTy,
280             typename std::iterator_traits<ItTy>::iterator_category,
281             typename std::remove_reference<FuncReturnTy>::type> {
282public:
283  mapped_iterator(ItTy U, FuncTy F)
284    : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
285 
286  ItTy getCurrent() { return this->I; }
287 
288  FuncReturnTy operator*() const { return F(*this->I); }
289 
290private:
291  FuncTy F;
292};
293 
294// map_iterator - Provide a convenient way to create mapped_iterators, just like
295// make_pair is useful for creating pairs...
296template <class ItTy, class FuncTy>
297inline mapped_iterator<ItTy, FuncTy> map_iterator(ItTy I, FuncTy F) {
298  return mapped_iterator<ItTy, FuncTy>(std::move(I), std::move(F));
299}
300 
301template <class ContainerTy, class FuncTy>
302auto map_range(ContainerTy &&C, FuncTy F) {
303  return make_range(map_iterator(C.begin(), F), map_iterator(C.end(), F));
304}
305 
306/// Helper to determine if type T has a member called rbegin().
307template <typename Ty> class has_rbegin_impl {
308  using yes = char[1];
309  using no = char[2];
310 
311  template <typename Inner>
312  static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
313 
314  template <typename>
315  static no& test(...);
316 
317public:
318  static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
319};
320 
321/// Metafunction to determine if T& or T has a member called rbegin().
322template <typename Ty>
323struct has_rbegin : has_rbegin_impl<typename std::remove_reference<Ty>::type> {
324};
325 
326// Returns an iterator_range over the given container which iterates in reverse.
327// Note that the container must have rbegin()/rend() methods for this to work.
328template <typename ContainerTy>
329auto reverse(ContainerTy &&C,
330             std::enable_if_t<has_rbegin<ContainerTy>::value> * = nullptr) {
331  return make_range(C.rbegin(), C.rend());
332}
333 
334// Returns a std::reverse_iterator wrapped around the given iterator.
335template <typename IteratorTy>
336std::reverse_iterator<IteratorTy> make_reverse_iterator(IteratorTy It) {
337  return std::reverse_iterator<IteratorTy>(It);
338}
339 
340// Returns an iterator_range over the given container which iterates in reverse.
341// Note that the container must have begin()/end() methods which return
342// bidirectional iterators for this to work.
343template <typename ContainerTy>
344auto reverse(ContainerTy &&C,
345             std::enable_if_t<!has_rbegin<ContainerTy>::value> * = nullptr) {
346  return make_range(llvm::make_reverse_iterator(std::end(C)),
347                    llvm::make_reverse_iterator(std::begin(C)));
348}
349 
350/// An iterator adaptor that filters the elements of given inner iterators.
351///
352/// The predicate parameter should be a callable object that accepts the wrapped
353/// iterator's reference type and returns a bool. When incrementing or
354/// decrementing the iterator, it will call the predicate on each element and
355/// skip any where it returns false.
356///
357/// \code
358///   int A[] = { 1, 2, 3, 4 };
359///   auto R = make_filter_range(A, [](int N) { return N % 2 == 1; });
360///   // R contains { 1, 3 }.
361/// \endcode
362///
363/// Note: filter_iterator_base implements support for forward iteration.
364/// filter_iterator_impl exists to provide support for bidirectional iteration,
365/// conditional on whether the wrapped iterator supports it.
366template <typename WrappedIteratorT, typename PredicateT, typename IterTag>
367class filter_iterator_base
368    : public iterator_adaptor_base<
369          filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
370          WrappedIteratorT,
371          typename std::common_type<
372              IterTag, typename std::iterator_traits<
373                           WrappedIteratorT>::iterator_category>::type> {
374  using BaseT = iterator_adaptor_base<
375      filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
376      WrappedIteratorT,
377      typename std::common_type<
378          IterTag, typename std::iterator_traits<
379                       WrappedIteratorT>::iterator_category>::type>;
380 
381protected:
382  WrappedIteratorT End;
383  PredicateT Pred;
384 
385  void findNextValid() {
386    while (this->I != End && !Pred(*this->I))
387      BaseT::operator++();
388  }
389 
390  // Construct the iterator. The begin iterator needs to know where the end
391  // is, so that it can properly stop when it gets there. The end iterator only
392  // needs the predicate to support bidirectional iteration.
393  filter_iterator_base(WrappedIteratorT Begin, WrappedIteratorT End,
394                       PredicateT Pred)
395      : BaseT(Begin), End(End), Pred(Pred) {
396    findNextValid();
397  }
398 
399public:
400  using BaseT::operator++;
401 
402  filter_iterator_base &operator++() {
403    BaseT::operator++();
404    findNextValid();
405    return *this;
406  }
407};
408 
409/// Specialization of filter_iterator_base for forward iteration only.
410template <typename WrappedIteratorT, typename PredicateT,
411          typename IterTag = std::forward_iterator_tag>
412class filter_iterator_impl
413    : public filter_iterator_base<WrappedIteratorT, PredicateT, IterTag> {
414  using BaseT = filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>;
415 
416public:
417  filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
418                       PredicateT Pred)
419      : BaseT(Begin, End, Pred) {}
420};
421 
422/// Specialization of filter_iterator_base for bidirectional iteration.
423template <typename WrappedIteratorT, typename PredicateT>
424class filter_iterator_impl<WrappedIteratorT, PredicateT,
425                           std::bidirectional_iterator_tag>
426    : public filter_iterator_base<WrappedIteratorT, PredicateT,
427                                  std::bidirectional_iterator_tag> {
428  using BaseT = filter_iterator_base<WrappedIteratorT, PredicateT,
429                                     std::bidirectional_iterator_tag>;
430  void findPrevValid() {
431    while (!this->Pred(*this->I))
432      BaseT::operator--();
433  }
434 
435public:
436  using BaseT::operator--;
437 
438  filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
439                       PredicateT Pred)
440      : BaseT(Begin, End, Pred) {}
441 
442  filter_iterator_impl &operator--() {
443    BaseT::operator--();
444    findPrevValid();
445    return *this;
446  }
447};
448 
449namespace detail {
450 
451template <bool is_bidirectional> struct fwd_or_bidi_tag_impl {
452  using type = std::forward_iterator_tag;
453};
454 
455template <> struct fwd_or_bidi_tag_impl<true> {
456  using type = std::bidirectional_iterator_tag;
457};
458 
459/// Helper which sets its type member to forward_iterator_tag if the category
460/// of \p IterT does not derive from bidirectional_iterator_tag, and to
461/// bidirectional_iterator_tag otherwise.
462template <typename IterT> struct fwd_or_bidi_tag {
463  using type = typename fwd_or_bidi_tag_impl<std::is_base_of<
464      std::bidirectional_iterator_tag,
465      typename std::iterator_traits<IterT>::iterator_category>::value>::type;
466};
467 
468} // namespace detail
469 
470/// Defines filter_iterator to a suitable specialization of
471/// filter_iterator_impl, based on the underlying iterator's category.
472template <typename WrappedIteratorT, typename PredicateT>
473using filter_iterator = filter_iterator_impl<
474    WrappedIteratorT, PredicateT,
475    typename detail::fwd_or_bidi_tag<WrappedIteratorT>::type>;
476 
477/// Convenience function that takes a range of elements and a predicate,
478/// and return a new filter_iterator range.
479///
480/// FIXME: Currently if RangeT && is a rvalue reference to a temporary, the
481/// lifetime of that temporary is not kept by the returned range object, and the
482/// temporary is going to be dropped on the floor after the make_iterator_range
483/// full expression that contains this function call.
484template <typename RangeT, typename PredicateT>
485iterator_range<filter_iterator<detail::IterOfRange<RangeT>, PredicateT>>
486make_filter_range(RangeT &&Range, PredicateT Pred) {
487  using FilterIteratorT =
488      filter_iterator<detail::IterOfRange<RangeT>, PredicateT>;
489  return make_range(
490      FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
491                      std::end(std::forward<RangeT>(Range)), Pred),
492      FilterIteratorT(std::end(std::forward<RangeT>(Range)),
493                      std::end(std::forward<RangeT>(Range)), Pred));
494}
495 
496/// A pseudo-iterator adaptor that is designed to implement "early increment"
497/// style loops.
498///
499/// This is *not a normal iterator* and should almost never be used directly. It
500/// is intended primarily to be used with range based for loops and some range
501/// algorithms.
502///
503/// The iterator isn't quite an `OutputIterator` or an `InputIterator` but
504/// somewhere between them. The constraints of these iterators are:
505///
506/// - On construction or after being incremented, it is comparable and
507///   dereferencable. It is *not* incrementable.
508/// - After being dereferenced, it is neither comparable nor dereferencable, it
509///   is only incrementable.
510///
511/// This means you can only dereference the iterator once, and you can only
512/// increment it once between dereferences.
513template <typename WrappedIteratorT>
514class early_inc_iterator_impl
515    : public iterator_adaptor_base<early_inc_iterator_impl<WrappedIteratorT>,
516                                   WrappedIteratorT, std::input_iterator_tag> {
517  using BaseT =
518      iterator_adaptor_base<early_inc_iterator_impl<WrappedIteratorT>,
519                            WrappedIteratorT, std::input_iterator_tag>;
520 
521  using PointerT = typename std::iterator_traits<WrappedIteratorT>::pointer;
522 
523protected:
524#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
525  bool IsEarlyIncremented = false;
526#endif
527 
528public:
529  early_inc_iterator_impl(WrappedIteratorT I) : BaseT(I) {}
530 
531  using BaseT::operator*;
532  decltype(*std::declval<WrappedIteratorT>()) operator*() {
533#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
534    assert(!IsEarlyIncremented && "Cannot dereference twice!")(static_cast<void> (0));
535    IsEarlyIncremented = true;
536#endif
537    return *(this->I)++;
538  }
539 
540  using BaseT::operator++;
541  early_inc_iterator_impl &operator++() {
542#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
543    assert(IsEarlyIncremented && "Cannot increment before dereferencing!")(static_cast<void> (0));
544    IsEarlyIncremented = false;
545#endif
546    return *this;
547  }
548 
549  friend bool operator==(const early_inc_iterator_impl &LHS,
550                         const early_inc_iterator_impl &RHS) {
551#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
552    assert(!LHS.IsEarlyIncremented && "Cannot compare after dereferencing!")(static_cast<void> (0));
553#endif
554    return (const BaseT &)LHS == (const BaseT &)RHS;
555  }
556};
557 
558/// Make a range that does early increment to allow mutation of the underlying
559/// range without disrupting iteration.
560///
561/// The underlying iterator will be incremented immediately after it is
562/// dereferenced, allowing deletion of the current node or insertion of nodes to
563/// not disrupt iteration provided they do not invalidate the *next* iterator --
564/// the current iterator can be invalidated.
565///
566/// This requires a very exact pattern of use that is only really suitable to
567/// range based for loops and other range algorithms that explicitly guarantee
568/// to dereference exactly once each element, and to increment exactly once each
569/// element.
570template <typename RangeT>
571iterator_range<early_inc_iterator_impl<detail::IterOfRange<RangeT>>>
572make_early_inc_range(RangeT &&Range) {
573  using EarlyIncIteratorT =
574      early_inc_iterator_impl<detail::IterOfRange<RangeT>>;
575  return make_range(EarlyIncIteratorT(std::begin(std::forward<RangeT>(Range))),
576                    EarlyIncIteratorT(std::end(std::forward<RangeT>(Range))));
577}
578 
579// forward declarations required by zip_shortest/zip_first/zip_longest
580template <typename R, typename UnaryPredicate>
581bool all_of(R &&range, UnaryPredicate P);
582template <typename R, typename UnaryPredicate>
583bool any_of(R &&range, UnaryPredicate P);
584 
585namespace detail {
586 
587using std::declval;
588 
589// We have to alias this since inlining the actual type at the usage site
590// in the parameter list of iterator_facade_base<> below ICEs MSVC 2017.
591template<typename... Iters> struct ZipTupleType {
592  using type = std::tuple<decltype(*declval<Iters>())...>;
593};
594 
595template <typename ZipType, typename... Iters>
596using zip_traits = iterator_facade_base<
597    ZipType, typename std::common_type<std::bidirectional_iterator_tag,
598                                       typename std::iterator_traits<
599                                           Iters>::iterator_category...>::type,
600    // ^ TODO: Implement random access methods.
601    typename ZipTupleType<Iters...>::type,
602    typename std::iterator_traits<typename std::tuple_element<
603        0, std::tuple<Iters...>>::type>::difference_type,
604    // ^ FIXME: This follows boost::make_zip_iterator's assumption that all
605    // inner iterators have the same difference_type. It would fail if, for
606    // instance, the second field's difference_type were non-numeric while the
607    // first is.
608    typename ZipTupleType<Iters...>::type *,
609    typename ZipTupleType<Iters...>::type>;
610 
611template <typename ZipType, typename... Iters>
612struct zip_common : public zip_traits<ZipType, Iters...> {
613  using Base = zip_traits<ZipType, Iters...>;
614  using value_type = typename Base::value_type;
615 
616  std::tuple<Iters...> iterators;
617 
618protected:
619  template <size_t... Ns> value_type deref(std::index_sequence<Ns...>) const {
620    return value_type(*std::get<Ns>(iterators)...);
621  }
622 
623  template <size_t... Ns>
624  decltype(iterators) tup_inc(std::index_sequence<Ns...>) const {
625    return std::tuple<Iters...>(std::next(std::get<Ns>(iterators))...);
626  }
627 
628  template <size_t... Ns>
629  decltype(iterators) tup_dec(std::index_sequence<Ns...>) const {
630    return std::tuple<Iters...>(std::prev(std::get<Ns>(iterators))...);
631  }
632 
633  template <size_t... Ns>
634  bool test_all_equals(const zip_common &other,
635            std::index_sequence<Ns...>) const {
636    return all_of(std::initializer_list<bool>{std::get<Ns>(this->iterators) ==
637                                              std::get<Ns>(other.iterators)...},
638                  identity<bool>{});
639  }
640 
641public:
642  zip_common(Iters &&... ts) : iterators(std::forward<Iters>(ts)...) {}
643 
644  value_type operator*() { return deref(std::index_sequence_for<Iters...>{}); }
645 
646  const value_type operator*() const {
647    return deref(std::index_sequence_for<Iters...>{});
648  }
649 
650  ZipType &operator++() {
651    iterators = tup_inc(std::index_sequence_for<Iters...>{});
652    return *reinterpret_cast<ZipType *>(this);
653  }
654 
655  ZipType &operator--() {
656    static_assert(Base::IsBidirectional,
657                  "All inner iterators must be at least bidirectional.");
658    iterators = tup_dec(std::index_sequence_for<Iters...>{});
659    return *reinterpret_cast<ZipType *>(this);
660  }
661 
662  /// Return true if all the iterator are matching `other`'s iterators.
663  bool all_equals(zip_common &other) {
664    return test_all_equals(other, std::index_sequence_for<Iters...>{});
665  }
666};
667 
668template <typename... Iters>
669struct zip_first : public zip_common<zip_first<Iters...>, Iters...> {
670  using Base = zip_common<zip_first<Iters...>, Iters...>;
671 
672  bool operator==(const zip_first<Iters...> &other) const {
673    return std::get<0>(this->iterators) == std::get<0>(other.iterators);
674  }
675 
676  zip_first(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
677};
678 
679template <typename... Iters>
680class zip_shortest : public zip_common<zip_shortest<Iters...>, Iters...> {
681  template <size_t... Ns>
682  bool test(const zip_shortest<Iters...> &other,
683            std::index_sequence<Ns...>) const {
684    return all_of(std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
685                                              std::get<Ns>(other.iterators)...},
686                  identity<bool>{});
687  }
688 
689public:
690  using Base = zip_common<zip_shortest<Iters...>, Iters...>;
691 
692  zip_shortest(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
693 
694  bool operator==(const zip_shortest<Iters...> &other) const {
695    return !test(other, std::index_sequence_for<Iters...>{});
696  }
697};
698 
699template <template <typename...> class ItType, typename... Args> class zippy {
700public:
701  using iterator = ItType<decltype(std::begin(std::declval<Args>()))...>;
702  using iterator_category = typename iterator::iterator_category;
703  using value_type = typename iterator::value_type;
704  using difference_type = typename iterator::difference_type;
705  using pointer = typename iterator::pointer;
706  using reference = typename iterator::reference;
707 
708private:
709  std::tuple<Args...> ts;
710 
711  template <size_t... Ns>
712  iterator begin_impl(std::index_sequence<Ns...>) const {
713    return iterator(std::begin(std::get<Ns>(ts))...);
714  }
715  template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) const {
716    return iterator(std::end(std::get<Ns>(ts))...);
717  }
718 
719public:
720  zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
721 
722  iterator begin() const {
723    return begin_impl(std::index_sequence_for<Args...>{});
724  }
725  iterator end() const { return end_impl(std::index_sequence_for<Args...>{}); }
726};
727 
728} // end namespace detail
729 
730/// zip iterator for two or more iteratable types.
731template <typename T, typename U, typename... Args>
732detail::zippy<detail::zip_shortest, T, U, Args...> zip(T &&t, U &&u,
733                                                       Args &&... args) {
734  return detail::zippy<detail::zip_shortest, T, U, Args...>(
735      std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
736}
737 
738/// zip iterator that, for the sake of efficiency, assumes the first iteratee to
739/// be the shortest.
740template <typename T, typename U, typename... Args>
741detail::zippy<detail::zip_first, T, U, Args...> zip_first(T &&t, U &&u,
742                                                          Args &&... args) {
743  return detail::zippy<detail::zip_first, T, U, Args...>(
744      std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
745}
746 
747namespace detail {
748template <typename Iter>
749Iter next_or_end(const Iter &I, const Iter &End) {
750  if (I == End)
751    return End;
752  return std::next(I);
753}
754 
755template <typename Iter>
756auto deref_or_none(const Iter &I, const Iter &End) -> llvm::Optional<
757    std::remove_const_t<std::remove_reference_t<decltype(*I)>>> {
758  if (I == End)
759    return None;
760  return *I;
761}
762 
763template <typename Iter> struct ZipLongestItemType {
764  using type =
765      llvm::Optional<typename std::remove_const<typename std::remove_reference<
766          decltype(*std::declval<Iter>())>::type>::type>;
767};
768 
769template <typename... Iters> struct ZipLongestTupleType {
770  using type = std::tuple<typename ZipLongestItemType<Iters>::type...>;
771};
772 
773template <typename... Iters>
774class zip_longest_iterator
775    : public iterator_facade_base<
776          zip_longest_iterator<Iters...>,
777          typename std::common_type<
778              std::forward_iterator_tag,
779              typename std::iterator_traits<Iters>::iterator_category...>::type,
780          typename ZipLongestTupleType<Iters...>::type,
781          typename std::iterator_traits<typename std::tuple_element<
782              0, std::tuple<Iters...>>::type>::difference_type,
783          typename ZipLongestTupleType<Iters...>::type *,
784          typename ZipLongestTupleType<Iters...>::type> {
785public:
786  using value_type = typename ZipLongestTupleType<Iters...>::type;
787 
788private:
789  std::tuple<Iters...> iterators;
790  std::tuple<Iters...> end_iterators;
791 
792  template <size_t... Ns>
793  bool test(const zip_longest_iterator<Iters...> &other,
794            std::index_sequence<Ns...>) const {
795    return llvm::any_of(
796        std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
797                                    std::get<Ns>(other.iterators)...},
798        identity<bool>{});
799  }
800 
801  template <size_t... Ns> value_type deref(std::index_sequence<Ns...>) const {
802    return value_type(
803        deref_or_none(std::get<Ns>(iterators), std::get<Ns>(end_iterators))...);
804  }
805 
806  template <size_t... Ns>
807  decltype(iterators) tup_inc(std::index_sequence<Ns...>) const {
808    return std::tuple<Iters...>(
809        next_or_end(std::get<Ns>(iterators), std::get<Ns>(end_iterators))...);
810  }
811 
812public:
813  zip_longest_iterator(std::pair<Iters &&, Iters &&>... ts)
814      : iterators(std::forward<Iters>(ts.first)...),
815        end_iterators(std::forward<Iters>(ts.second)...) {}
816 
817  value_type operator*() { return deref(std::index_sequence_for<Iters...>{}); }
818 
819  value_type operator*() const {
820    return deref(std::index_sequence_for<Iters...>{});
821  }
822 
823  zip_longest_iterator<Iters...> &operator++() {
824    iterators = tup_inc(std::index_sequence_for<Iters...>{});
825    return *this;
826  }
827 
828  bool operator==(const zip_longest_iterator<Iters...> &other) const {
829    return !test(other, std::index_sequence_for<Iters...>{});
830  }
831};
832 
833template <typename... Args> class zip_longest_range {
834public:
835  using iterator =
836      zip_longest_iterator<decltype(adl_begin(std::declval<Args>()))...>;
837  using iterator_category = typename iterator::iterator_category;
838  using value_type = typename iterator::value_type;
839  using difference_type = typename iterator::difference_type;
840  using pointer = typename iterator::pointer;
841  using reference = typename iterator::reference;
842 
843private:
844  std::tuple<Args...> ts;
845 
846  template <size_t... Ns>
847  iterator begin_impl(std::index_sequence<Ns...>) const {
848    return iterator(std::make_pair(adl_begin(std::get<Ns>(ts)),
849                                   adl_end(std::get<Ns>(ts)))...);
850  }
851 
852  template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) const {
853    return iterator(std::make_pair(adl_end(std::get<Ns>(ts)),
854                                   adl_end(std::get<Ns>(ts)))...);
855  }
856 
857public:
858  zip_longest_range(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
859 
860  iterator begin() const {
861    return begin_impl(std::index_sequence_for<Args...>{});
862  }
863  iterator end() const { return end_impl(std::index_sequence_for<Args...>{}); }
864};
865} // namespace detail
866 
867/// Iterate over two or more iterators at the same time. Iteration continues
868/// until all iterators reach the end. The llvm::Optional only contains a value
869/// if the iterator has not reached the end.
870template <typename T, typename U, typename... Args>
871detail::zip_longest_range<T, U, Args...> zip_longest(T &&t, U &&u,
872                                                     Args &&... args) {
873  return detail::zip_longest_range<T, U, Args...>(
874      std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
875}
876 
877/// Iterator wrapper that concatenates sequences together.
878///
879/// This can concatenate different iterators, even with different types, into
880/// a single iterator provided the value types of all the concatenated
881/// iterators expose `reference` and `pointer` types that can be converted to
882/// `ValueT &` and `ValueT *` respectively. It doesn't support more
883/// interesting/customized pointer or reference types.
884///
885/// Currently this only supports forward or higher iterator categories as
886/// inputs and always exposes a forward iterator interface.
887template <typename ValueT, typename... IterTs>
888class concat_iterator
889    : public iterator_facade_base<concat_iterator<ValueT, IterTs...>,
890                                  std::forward_iterator_tag, ValueT> {
891  using BaseT = typename concat_iterator::iterator_facade_base;
892 
893  /// We store both the current and end iterators for each concatenated
894  /// sequence in a tuple of pairs.
895  ///
896  /// Note that something like iterator_range seems nice at first here, but the
897  /// range properties are of little benefit and end up getting in the way
898  /// because we need to do mutation on the current iterators.
899  std::tuple<IterTs...> Begins;
900  std::tuple<IterTs...> Ends;
901 
902  /// Attempts to increment a specific iterator.
903  ///
904  /// Returns true if it was able to increment the iterator. Returns false if
905  /// the iterator is already at the end iterator.
906  template <size_t Index> bool incrementHelper() {
907    auto &Begin = std::get<Index>(Begins);
908    auto &End = std::get<Index>(Ends);
909    if (Begin == End)
910      return false;
911 
912    ++Begin;
913    return true;
914  }
915 
916  /// Increments the first non-end iterator.
917  ///
918  /// It is an error to call this with all iterators at the end.
919  template <size_t... Ns> void increment(std::index_sequence<Ns...>) {
920    // Build a sequence of functions to increment each iterator if possible.
921    bool (concat_iterator::*IncrementHelperFns[])() = {
922        &concat_iterator::incrementHelper<Ns>...};
923 
924    // Loop over them, and stop as soon as we succeed at incrementing one.
925    for (auto &IncrementHelperFn : IncrementHelperFns)
926      if ((this->*IncrementHelperFn)())
927        return;
928 
929    llvm_unreachable("Attempted to increment an end concat iterator!")__builtin_unreachable();
930  }
931 
932  /// Returns null if the specified iterator is at the end. Otherwise,
933  /// dereferences the iterator and returns the address of the resulting
934  /// reference.
935  template <size_t Index> ValueT *getHelper() const {
936    auto &Begin = std::get<Index>(Begins);
937    auto &End = std::get<Index>(Ends);
938    if (Begin == End)
939      return nullptr;
940 
941    return &*Begin;
942  }
943 
944  /// Finds the first non-end iterator, dereferences, and returns the resulting
945  /// reference.
946  ///
947  /// It is an error to call this with all iterators at the end.
948  template <size_t... Ns> ValueT &get(std::index_sequence<Ns...>) const {
949    // Build a sequence of functions to get from iterator if possible.
950    ValueT *(concat_iterator::*GetHelperFns[])() const = {
951        &concat_iterator::getHelper<Ns>...};
952 
953    // Loop over them, and return the first result we find.
954    for (auto &GetHelperFn : GetHelperFns)
955      if (ValueT *P = (this->*GetHelperFn)())
956        return *P;
957 
958    llvm_unreachable("Attempted to get a pointer from an end concat iterator!")__builtin_unreachable();
959  }
960 
961public:
962  /// Constructs an iterator from a sequence of ranges.
963  ///
964  /// We need the full range to know how to switch between each of the
965  /// iterators.
966  template <typename... RangeTs>
967  explicit concat_iterator(RangeTs &&... Ranges)
968      : Begins(std::begin(Ranges)...), Ends(std::end(Ranges)...) {}
969 
970  using BaseT::operator++;
971 
972  concat_iterator &operator++() {
973    increment(std::index_sequence_for<IterTs...>());
974    return *this;
975  }
976 
977  ValueT &operator*() const {
978    return get(std::index_sequence_for<IterTs...>());
979  }
980 
981  bool operator==(const concat_iterator &RHS) const {
982    return Begins == RHS.Begins && Ends == RHS.Ends;
983  }
984};
985 
986namespace detail {
987 
988/// Helper to store a sequence of ranges being concatenated and access them.
989///
990/// This is designed to facilitate providing actual storage when temporaries
991/// are passed into the constructor such that we can use it as part of range
992/// based for loops.
993template <typename ValueT, typename... RangeTs> class concat_range {
994public:
995  using iterator =
996      concat_iterator<ValueT,
997                      decltype(std::begin(std::declval<RangeTs &>()))...>;
998 
999private:
1000  std::tuple<RangeTs...> Ranges;
1001 
1002  template <size_t... Ns> iterator begin_impl(std::index_sequence<Ns...>) {
1003    return iterator(std::get<Ns>(Ranges)...);
1004  }
1005  template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) {
1006    return iterator(make_range(std::end(std::get<Ns>(Ranges)),
1007                               std::end(std::get<Ns>(Ranges)))...);
1008  }
1009 
1010public:
1011  concat_range(RangeTs &&... Ranges)
1012      : Ranges(std::forward<RangeTs>(Ranges)...) {}
1013 
1014  iterator begin() { return begin_impl(std::index_sequence_for<RangeTs...>{}); }
1015  iterator end() { return end_impl(std::index_sequence_for<RangeTs...>{}); }
1016};
1017 
1018} // end namespace detail
1019 
1020/// Concatenated range across two or more ranges.
1021///
1022/// The desired value type must be explicitly specified.
1023template <typename ValueT, typename... RangeTs>
1024detail::concat_range<ValueT, RangeTs...> concat(RangeTs &&... Ranges) {
1025  static_assert(sizeof...(RangeTs) > 1,
1026                "Need more than one range to concatenate!");
1027  return detail::concat_range<ValueT, RangeTs...>(
1028      std::forward<RangeTs>(Ranges)...);
1029}
1030 
1031/// A utility class used to implement an iterator that contains some base object
1032/// and an index. The iterator moves the index but keeps the base constant.
1033template <typename DerivedT, typename BaseT, typename T,
1034          typename PointerT = T *, typename ReferenceT = T &>
1035class indexed_accessor_iterator
1036    : public llvm::iterator_facade_base<DerivedT,
1037                                        std::random_access_iterator_tag, T,
1038                                        std::ptrdiff_t, PointerT, ReferenceT> {
1039public:
1040  ptrdiff_t operator-(const indexed_accessor_iterator &rhs) const {
1041    assert(base == rhs.base && "incompatible iterators")(static_cast<void> (0));
1042    return index - rhs.index;
1043  }
1044  bool operator==(const indexed_accessor_iterator &rhs) const {
1045    return base == rhs.base && index == rhs.index;
1046  }
1047  bool operator<(const indexed_accessor_iterator &rhs) const {
1048    assert(base == rhs.base && "incompatible iterators")(static_cast<void> (0));
1049    return index < rhs.index;
1050  }
1051 
1052  DerivedT &operator+=(ptrdiff_t offset) {
1053    this->index += offset;
1054    return static_cast<DerivedT &>(*this);
1055  }
1056  DerivedT &operator-=(ptrdiff_t offset) {
1057    this->index -= offset;
1058    return static_cast<DerivedT &>(*this);
1059  }
1060 
1061  /// Returns the current index of the iterator.
1062  ptrdiff_t getIndex() const { return index; }
1063 
1064  /// Returns the current base of the iterator.
1065  const BaseT &getBase() const { return base; }
1066 
1067protected:
1068  indexed_accessor_iterator(BaseT base, ptrdiff_t index)
1069      : base(base), index(index) {}
1070  BaseT base;
1071  ptrdiff_t index;
1072};
1073 
1074namespace detail {
1075/// The class represents the base of a range of indexed_accessor_iterators. It
1076/// provides support for many different range functionalities, e.g.
1077/// drop_front/slice/etc.. Derived range classes must implement the following
1078/// static methods:
1079///   * ReferenceT dereference_iterator(const BaseT &base, ptrdiff_t index)
1080///     - Dereference an iterator pointing to the base object at the given
1081///       index.
1082///   * BaseT offset_base(const BaseT &base, ptrdiff_t index)
1083///     - Return a new base that is offset from the provide base by 'index'
1084///       elements.
1085template <typename DerivedT, typename BaseT, typename T,
1086          typename PointerT = T *, typename ReferenceT = T &>
1087class indexed_accessor_range_base {
1088public:
1089  using RangeBaseT =
1090      indexed_accessor_range_base<DerivedT, BaseT, T, PointerT, ReferenceT>;
1091 
1092  /// An iterator element of this range.
1093  class iterator : public indexed_accessor_iterator<iterator, BaseT, T,
1094                                                    PointerT, ReferenceT> {
1095  public:
1096    // Index into this iterator, invoking a static method on the derived type.
1097    ReferenceT operator*() const {
1098      return DerivedT::dereference_iterator(this->getBase(), this->getIndex());
1099    }
1100 
1101  private:
1102    iterator(BaseT owner, ptrdiff_t curIndex)
1103        : indexed_accessor_iterator<iterator, BaseT, T, PointerT, ReferenceT>(
1104              owner, curIndex) {}
1105 
1106    /// Allow access to the constructor.
1107    friend indexed_accessor_range_base<DerivedT, BaseT, T, PointerT,
1108                                       ReferenceT>;
1109  };
1110 
1111  indexed_accessor_range_base(iterator begin, iterator end)
1112      : base(offset_base(begin.getBase(), begin.getIndex())),
1113        count(end.getIndex() - begin.getIndex()) {}
1114  indexed_accessor_range_base(const iterator_range<iterator> &range)
1115      : indexed_accessor_range_base(range.begin(), range.end()) {}
1116  indexed_accessor_range_base(BaseT base, ptrdiff_t count)
1117      : base(base), count(count) {}
1118 
1119  iterator begin() const { return iterator(base, 0); }
1120  iterator end() const { return iterator(base, count); }
1121  ReferenceT operator[](size_t Index) const {
1122    assert(Index < size() && "invalid index for value range")(static_cast<void> (0));
1123    return DerivedT::dereference_iterator(base, static_cast<ptrdiff_t>(Index));
1124  }
1125  ReferenceT front() const {
1126    assert(!empty() && "expected non-empty range")(static_cast<void> (0));
1127    return (*this)[0];
1128  }
1129  ReferenceT back() const {
1130    assert(!empty() && "expected non-empty range")(static_cast<void> (0));
1131    return (*this)[size() - 1];
1132  }
1133 
1134  /// Compare this range with another.
1135  template <typename OtherT> bool operator==(const OtherT &other) const {
1136    return size() ==
1137               static_cast<size_t>(std::distance(other.begin(), other.end())) &&
1138           std::equal(begin(), end(), other.begin());
1139  }
1140  template <typename OtherT> bool operator!=(const OtherT &other) const {
1141    return !(*this == other);
1142  }
1143 
1144  /// Return the size of this range.
1145  size_t size() const { return count; }
1146 
1147  /// Return if the range is empty.
1148  bool empty() const { return size() == 0; }
1149 
1150  /// Drop the first N elements, and keep M elements.
1151  DerivedT slice(size_t n, size_t m) const {
1152    assert(n + m <= size() && "invalid size specifiers")(static_cast<void> (0));
1153    return DerivedT(offset_base(base, n), m);
1154  }
1155 
1156  /// Drop the first n elements.
1157  DerivedT drop_front(size_t n = 1) const {
1158    assert(size() >= n && "Dropping more elements than exist")(static_cast<void> (0));
1159    return slice(n, size() - n);
1160  }
1161  /// Drop the last n elements.
1162  DerivedT drop_back(size_t n = 1) const {
1163    assert(size() >= n && "Dropping more elements than exist")(static_cast<void> (0));
1164    return DerivedT(base, size() - n);
1165  }
1166 
1167  /// Take the first n elements.
1168  DerivedT take_front(size_t n = 1) const {
1169    return n < size() ? drop_back(size() - n)
1170                      : static_cast<const DerivedT &>(*this);
1171  }
1172 
1173  /// Take the last n elements.
1174  DerivedT take_back(size_t n = 1) const {
1175    return n < size() ? drop_front(size() - n)
1176                      : static_cast<const DerivedT &>(*this);
1177  }
1178 
1179  /// Allow conversion to any type accepting an iterator_range.
1180  template <typename RangeT, typename = std::enable_if_t<std::is_constructible<
1181                                 RangeT, iterator_range<iterator>>::value>>
1182  operator RangeT() const {
1183    return RangeT(iterator_range<iterator>(*this));
1184  }
1185 
1186  /// Returns the base of this range.
1187  const BaseT &getBase() const { return base; }
1188 
1189private:
1190  /// Offset the given base by the given amount.
1191  static BaseT offset_base(const BaseT &base, size_t n) {
1192    return n == 0 ? base : DerivedT::offset_base(base, n);
1193  }
1194 
1195protected:
1196  indexed_accessor_range_base(const indexed_accessor_range_base &) = default;
1197  indexed_accessor_range_base(indexed_accessor_range_base &&) = default;
1198  indexed_accessor_range_base &
1199  operator=(const indexed_accessor_range_base &) = default;
1200 
1201  /// The base that owns the provided range of values.
1202  BaseT base;
1203  /// The size from the owning range.
1204  ptrdiff_t count;
1205};
1206} // end namespace detail
1207 
1208/// This class provides an implementation of a range of
1209/// indexed_accessor_iterators where the base is not indexable. Ranges with
1210/// bases that are offsetable should derive from indexed_accessor_range_base
1211/// instead. Derived range classes are expected to implement the following
1212/// static method:
1213///   * ReferenceT dereference(const BaseT &base, ptrdiff_t index)
1214///     - Dereference an iterator pointing to a parent base at the given index.
1215template <typename DerivedT, typename BaseT, typename T,
1216          typename PointerT = T *, typename ReferenceT = T &>
1217class indexed_accessor_range
1218    : public detail::indexed_accessor_range_base<
1219          DerivedT, std::pair<BaseT, ptrdiff_t>, T, PointerT, ReferenceT> {
1220public:
1221  indexed_accessor_range(BaseT base, ptrdiff_t startIndex, ptrdiff_t count)
1222      : detail::indexed_accessor_range_base<
1223            DerivedT, std::pair<BaseT, ptrdiff_t>, T, PointerT, ReferenceT>(
1224            std::make_pair(base, startIndex), count) {}
1225  using detail::indexed_accessor_range_base<
1226      DerivedT, std::pair<BaseT, ptrdiff_t>, T, PointerT,
1227      ReferenceT>::indexed_accessor_range_base;
1228 
1229  /// Returns the current base of the range.
1230  const BaseT &getBase() const { return this->base.first; }
1231 
1232  /// Returns the current start index of the range.
1233  ptrdiff_t getStartIndex() const { return this->base.second; }
1234 
1235  /// See `detail::indexed_accessor_range_base` for details.
1236  static std::pair<BaseT, ptrdiff_t>
1237  offset_base(const std::pair<BaseT, ptrdiff_t> &base, ptrdiff_t index) {
1238    // We encode the internal base as a pair of the derived base and a start
1239    // index into the derived base.
1240    return std::make_pair(base.first, base.second + index);
1241  }
1242  /// See `detail::indexed_accessor_range_base` for details.
1243  static ReferenceT
1244  dereference_iterator(const std::pair<BaseT, ptrdiff_t> &base,
1245                       ptrdiff_t index) {
1246    return DerivedT::dereference(base.first, base.second + index);
1247  }
1248};
1249 
1250/// Given a container of pairs, return a range over the first elements.
1251template <typename ContainerTy> auto make_first_range(ContainerTy &&c) {
1252  return llvm::map_range(
1253      std::forward<ContainerTy>(c),
1254      [](decltype((*std::begin(c))) elt) -> decltype((elt.first)) {
1255        return elt.first;
1256      });
1257}
1258 
1259/// Given a container of pairs, return a range over the second elements.
1260template <typename ContainerTy> auto make_second_range(ContainerTy &&c) {
1261  return llvm::map_range(
1262      std::forward<ContainerTy>(c),
1263      [](decltype((*std::begin(c))) elt) -> decltype((elt.second)) {
1264        return elt.second;
1265      });
1266}
1267 
1268//===----------------------------------------------------------------------===//
1269//     Extra additions to <utility>
1270//===----------------------------------------------------------------------===//
1271 
1272/// Function object to check whether the first component of a std::pair
1273/// compares less than the first component of another std::pair.
1274struct less_first {
1275  template <typename T> bool operator()(const T &lhs, const T &rhs) const {
1276    return std::less<>()(lhs.first, rhs.first);
1277  }
1278};
1279 
1280/// Function object to check whether the second component of a std::pair
1281/// compares less than the second component of another std::pair.
1282struct less_second {
1283  template <typename T> bool operator()(const T &lhs, const T &rhs) const {
1284    return std::less<>()(lhs.second, rhs.second);
1285  }
1286};
1287 
1288/// \brief Function object to apply a binary function to the first component of
1289/// a std::pair.
1290template<typename FuncTy>
1291struct on_first {
1292  FuncTy func;
1293 
1294  template <typename T>
1295  decltype(auto) operator()(const T &lhs, const T &rhs) const {
1296    return func(lhs.first, rhs.first);
1297  }
1298};
1299 
1300/// Utility type to build an inheritance chain that makes it easy to rank
1301/// overload candidates.
1302template <int N> struct rank : rank<N - 1> {};
1303template <> struct rank<0> {};
1304 
1305/// traits class for checking whether type T is one of any of the given
1306/// types in the variadic list.
1307template <typename T, typename... Ts>
1308using is_one_of = disjunction<std::is_same<T, Ts>...>;
1309 
1310/// traits class for checking whether type T is a base class for all
1311///  the given types in the variadic list.
1312template <typename T, typename... Ts>
1313using are_base_of = conjunction<std::is_base_of<T, Ts>...>;
1314 
1315namespace detail {
1316template <typename... Ts> struct Visitor;
1317 
1318template <typename HeadT, typename... TailTs>
1319struct Visitor<HeadT, TailTs...> : remove_cvref_t<HeadT>, Visitor<TailTs...> {
1320  explicit constexpr Visitor(HeadT &&Head, TailTs &&...Tail)
1321      : remove_cvref_t<HeadT>(std::forward<HeadT>(Head)),
1322        Visitor<TailTs...>(std::forward<TailTs>(Tail)...) {}
1323  using remove_cvref_t<HeadT>::operator();
1324  using Visitor<TailTs...>::operator();
1325};
1326 
1327template <typename HeadT> struct Visitor<HeadT> : remove_cvref_t<HeadT> {
1328  explicit constexpr Visitor(HeadT &&Head)
1329      : remove_cvref_t<HeadT>(std::forward<HeadT>(Head)) {}
1330  using remove_cvref_t<HeadT>::operator();
1331};
1332} // namespace detail
1333 
1334/// Returns an opaquely-typed Callable object whose operator() overload set is
1335/// the sum of the operator() overload sets of each CallableT in CallableTs.
1336///
1337/// The type of the returned object derives from each CallableT in CallableTs.
1338/// The returned object is constructed by invoking the appropriate copy or move
1339/// constructor of each CallableT, as selected by overload resolution on the
1340/// corresponding argument to makeVisitor.
1341///
1342/// Example:
1343///
1344/// \code
1345/// auto visitor = makeVisitor([](auto) { return "unhandled type"; },
1346///                            [](int i) { return "int"; },
1347///                            [](std::string s) { return "str"; });
1348/// auto a = visitor(42);    // `a` is now "int".
1349/// auto b = visitor("foo"); // `b` is now "str".
1350/// auto c = visitor(3.14f); // `c` is now "unhandled type".
1351/// \endcode
1352///
1353/// Example of making a visitor with a lambda which captures a move-only type:
1354///
1355/// \code
1356/// std::unique_ptr<FooHandler> FH = /* ... */;
1357/// auto visitor = makeVisitor(
1358///     [FH{std::move(FH)}](Foo F) { return FH->handle(F); },
1359///     [](int i) { return i; },
1360///     [](std::string s) { return atoi(s); });
1361/// \endcode
1362template <typename... CallableTs>
1363constexpr decltype(auto) makeVisitor(CallableTs &&...Callables) {
1364  return detail::Visitor<CallableTs...>(std::forward<CallableTs>(Callables)...);
1365}
1366 
1367//===----------------------------------------------------------------------===//
1368//     Extra additions for arrays
1369//===----------------------------------------------------------------------===//
1370 
1371// We have a copy here so that LLVM behaves the same when using different
1372// standard libraries.
1373template <class Iterator, class RNG>
1374void shuffle(Iterator first, Iterator last, RNG &&g) {
1375  // It would be better to use a std::uniform_int_distribution,
1376  // but that would be stdlib dependent.
1377  typedef
1378      typename std::iterator_traits<Iterator>::difference_type difference_type;
1379  for (auto size = last - first; size > 1; ++first, (void)--size) {
1380    difference_type offset = g() % size;
1381    // Avoid self-assignment due to incorrect assertions in libstdc++
1382    // containers (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85828).
1383    if (offset != difference_type(0))
1384      std::iter_swap(first, first + offset);
1385  }
1386}
1387 
1388/// Find the length of an array.
1389template <class T, std::size_t N>
1390constexpr inline size_t array_lengthof(T (&)[N]) {
1391  return N;
1392}
1393 
1394/// Adapt std::less<T> for array_pod_sort.
1395template<typename T>
1396inline int array_pod_sort_comparator(const void *P1, const void *P2) {
1397  if (std::less<T>()(*reinterpret_cast<const T*>(P1),
1398                     *reinterpret_cast<const T*>(P2)))
1399    return -1;
1400  if (std::less<T>()(*reinterpret_cast<const T*>(P2),
1401                     *reinterpret_cast<const T*>(P1)))
1402    return 1;
1403  return 0;
1404}
1405 
1406/// get_array_pod_sort_comparator - This is an internal helper function used to
1407/// get type deduction of T right.
1408template<typename T>
1409inline int (*get_array_pod_sort_comparator(const T &))
1410             (const void*, const void*) {
1411  return array_pod_sort_comparator<T>;
1412}
1413 
1414#ifdef EXPENSIVE_CHECKS
1415namespace detail {
1416 
1417inline unsigned presortShuffleEntropy() {
1418  static unsigned Result(std::random_device{}());
1419  return Result;
1420}
1421 
1422template <class IteratorTy>
1423inline void presortShuffle(IteratorTy Start, IteratorTy End) {
1424  std::mt19937 Generator(presortShuffleEntropy());
1425  llvm::shuffle(Start, End, Generator);
1426}
1427 
1428} // end namespace detail
1429#endif
1430 
1431/// array_pod_sort - This sorts an array with the specified start and end
1432/// extent.  This is just like std::sort, except that it calls qsort instead of
1433/// using an inlined template.  qsort is slightly slower than std::sort, but
1434/// most sorts are not performance critical in LLVM and std::sort has to be
1435/// template instantiated for each type, leading to significant measured code
1436/// bloat.  This function should generally be used instead of std::sort where
1437/// possible.
1438///
1439/// This function assumes that you have simple POD-like types that can be
1440/// compared with std::less and can be moved with memcpy.  If this isn't true,
1441/// you should use std::sort.
1442///
1443/// NOTE: If qsort_r were portable, we could allow a custom comparator and
1444/// default to std::less.
1445template<class IteratorTy>
1446inline void array_pod_sort(IteratorTy Start, IteratorTy End) {
1447  // Don't inefficiently call qsort with one element or trigger undefined
1448  // behavior with an empty sequence.
1449  auto NElts = End - Start;
1450  if (NElts <= 1) return;
1451#ifdef EXPENSIVE_CHECKS
1452  detail::presortShuffle<IteratorTy>(Start, End);
1453#endif
1454  qsort(&*Start, NElts, sizeof(*Start), get_array_pod_sort_comparator(*Start));
1455}
1456 
1457template <class IteratorTy>
1458inline void array_pod_sort(
1459    IteratorTy Start, IteratorTy End,
1460    int (*Compare)(
1461        const typename std::iterator_traits<IteratorTy>::value_type *,
1462        const typename std::iterator_traits<IteratorTy>::value_type *)) {
1463  // Don't inefficiently call qsort with one element or trigger undefined
1464  // behavior with an empty sequence.
1465  auto NElts = End - Start;
1466  if (NElts <= 1) return;
1467#ifdef EXPENSIVE_CHECKS
1468  detail::presortShuffle<IteratorTy>(Start, End);
1469#endif
1470  qsort(&*Start, NElts, sizeof(*Start),
1471        reinterpret_cast<int (*)(const void *, const void *)>(Compare));
1472}
1473 
1474namespace detail {
1475template <typename T>
1476// We can use qsort if the iterator type is a pointer and the underlying value
1477// is trivially copyable.
1478using sort_trivially_copyable = conjunction<
1479    std::is_pointer<T>,
1480    std::is_trivially_copyable<typename std::iterator_traits<T>::value_type>>;
1481} // namespace detail
1482 
1483// Provide wrappers to std::sort which shuffle the elements before sorting
1484// to help uncover non-deterministic behavior (PR35135).
1485template <typename IteratorTy,
1486          std::enable_if_t<!detail::sort_trivially_copyable<IteratorTy>::value,
1487                           int> = 0>
1488inline void sort(IteratorTy Start, IteratorTy End) {
1489#ifdef EXPENSIVE_CHECKS
1490  detail::presortShuffle<IteratorTy>(Start, End);
1491#endif
1492  std::sort(Start, End);
1493}
1494 
1495// Forward trivially copyable types to array_pod_sort. This avoids a large
1496// amount of code bloat for a minor performance hit.
1497template <typename IteratorTy,
1498          std::enable_if_t<detail::sort_trivially_copyable<IteratorTy>::value,
1499                           int> = 0>
1500inline void sort(IteratorTy Start, IteratorTy End) {
1501  array_pod_sort(Start, End);
1502}
1503 
1504template <typename Container> inline void sort(Container &&C) {
1505  llvm::sort(adl_begin(C), adl_end(C));
1506}
1507 
1508template <typename IteratorTy, typename Compare>
1509inline void sort(IteratorTy Start, IteratorTy End, Compare Comp) {
1510#ifdef EXPENSIVE_CHECKS
1511  detail::presortShuffle<IteratorTy>(Start, End);
1512#endif
1513  std::sort(Start, End, Comp);
1514}
1515 
1516template <typename Container, typename Compare>
1517inline void sort(Container &&C, Compare Comp) {
1518  llvm::sort(adl_begin(C), adl_end(C), Comp);
1519}
1520 
1521//===----------------------------------------------------------------------===//
1522//     Extra additions to <algorithm>
1523//===----------------------------------------------------------------------===//
1524 
1525/// Get the size of a range. This is a wrapper function around std::distance
1526/// which is only enabled when the operation is O(1).
1527template <typename R>
1528auto size(R &&Range,
1529          std::enable_if_t<
1530              std::is_base_of<std::random_access_iterator_tag,
1531                              typename std::iterator_traits<decltype(
1532                                  Range.begin())>::iterator_category>::value,
1533              void> * = nullptr) {
1534  return std::distance(Range.begin(), Range.end());
1535}
1536 
1537/// Provide wrappers to std::for_each which take ranges instead of having to
1538/// pass begin/end explicitly.
1539template <typename R, typename UnaryFunction>
1540UnaryFunction for_each(R &&Range, UnaryFunction F) {
1541  return std::for_each(adl_begin(Range), adl_end(Range), F);
1542}
1543 
1544/// Provide wrappers to std::all_of which take ranges instead of having to pass
1545/// begin/end explicitly.
1546template <typename R, typename UnaryPredicate>
1547bool all_of(R &&Range, UnaryPredicate P) {
1548  return std::all_of(adl_begin(Range), adl_end(Range), P);
1549}
1550 
1551/// Provide wrappers to std::any_of which take ranges instead of having to pass
1552/// begin/end explicitly.
1553template <typename R, typename UnaryPredicate>
1554bool any_of(R &&Range, UnaryPredicate P) {
1555  return std::any_of(adl_begin(Range), adl_end(Range), P);
8
←
Calling 'any_of<const unsigned long *, (lambda at /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/ADT/BitVector.h:163:25)>'→
14
←
Returning from 'any_of<const unsigned long *, (lambda at /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/ADT/BitVector.h:163:25)>'→
15
←
Returning the value 1, which participates in a condition later→
1556}
1557 
1558/// Provide wrappers to std::none_of which take ranges instead of having to pass
1559/// begin/end explicitly.
1560template <typename R, typename UnaryPredicate>
1561bool none_of(R &&Range, UnaryPredicate P) {
1562  return std::none_of(adl_begin(Range), adl_end(Range), P);
1563}
1564 
1565/// Provide wrappers to std::find which take ranges instead of having to pass
1566/// begin/end explicitly.
1567template <typename R, typename T> auto find(R &&Range, const T &Val) {
1568  return std::find(adl_begin(Range), adl_end(Range), Val);
1569}
1570 
1571/// Provide wrappers to std::find_if which take ranges instead of having to pass
1572/// begin/end explicitly.
1573template <typename R, typename UnaryPredicate>
1574auto find_if(R &&Range, UnaryPredicate P) {
1575  return std::find_if(adl_begin(Range), adl_end(Range), P);
1576}
1577 
1578template <typename R, typename UnaryPredicate>
1579auto find_if_not(R &&Range, UnaryPredicate P) {
1580  return std::find_if_not(adl_begin(Range), adl_end(Range), P);
1581}
1582 
1583/// Provide wrappers to std::remove_if which take ranges instead of having to
1584/// pass begin/end explicitly.
1585template <typename R, typename UnaryPredicate>
1586auto remove_if(R &&Range, UnaryPredicate P) {
1587  return std::remove_if(adl_begin(Range), adl_end(Range), P);
1588}
1589 
1590/// Provide wrappers to std::copy_if which take ranges instead of having to
1591/// pass begin/end explicitly.
1592template <typename R, typename OutputIt, typename UnaryPredicate>
1593OutputIt copy_if(R &&Range, OutputIt Out, UnaryPredicate P) {
1594  return std::copy_if(adl_begin(Range), adl_end(Range), Out, P);
1595}
1596 
1597template <typename R, typename OutputIt>
1598OutputIt copy(R &&Range, OutputIt Out) {
1599  return std::copy(adl_begin(Range), adl_end(Range), Out);
1600}
1601 
1602/// Provide wrappers to std::move which take ranges instead of having to
1603/// pass begin/end explicitly.
1604template <typename R, typename OutputIt>
1605OutputIt move(R &&Range, OutputIt Out) {
1606  return std::move(adl_begin(Range), adl_end(Range), Out);
1607}
1608 
1609/// Wrapper function around std::find to detect if an element exists
1610/// in a container.
1611template <typename R, typename E>
1612bool is_contained(R &&Range, const E &Element) {
1613  return std::find(adl_begin(Range), adl_end(Range), Element) != adl_end(Range);
1614}
1615 
1616/// Wrapper function around std::is_sorted to check if elements in a range \p R
1617/// are sorted with respect to a comparator \p C.
1618template <typename R, typename Compare> bool is_sorted(R &&Range, Compare C) {
1619  return std::is_sorted(adl_begin(Range), adl_end(Range), C);
1620}
1621 
1622/// Wrapper function around std::is_sorted to check if elements in a range \p R
1623/// are sorted in non-descending order.
1624template <typename R> bool is_sorted(R &&Range) {
1625  return std::is_sorted(adl_begin(Range), adl_end(Range));
1626}
1627 
1628/// Wrapper function around std::count to count the number of times an element
1629/// \p Element occurs in the given range \p Range.
1630template <typename R, typename E> auto count(R &&Range, const E &Element) {
1631  return std::count(adl_begin(Range), adl_end(Range), Element);
1632}
1633 
1634/// Wrapper function around std::count_if to count the number of times an
1635/// element satisfying a given predicate occurs in a range.
1636template <typename R, typename UnaryPredicate>
1637auto count_if(R &&Range, UnaryPredicate P) {
1638  return std::count_if(adl_begin(Range), adl_end(Range), P);
1639}
1640 
1641/// Wrapper function around std::transform to apply a function to a range and
1642/// store the result elsewhere.
1643template <typename R, typename OutputIt, typename UnaryFunction>
1644OutputIt transform(R &&Range, OutputIt d_first, UnaryFunction F) {
1645  return std::transform(adl_begin(Range), adl_end(Range), d_first, F);
1646}
1647 
1648/// Provide wrappers to std::partition which take ranges instead of having to
1649/// pass begin/end explicitly.
1650template <typename R, typename UnaryPredicate>
1651auto partition(R &&Range, UnaryPredicate P) {
1652  return std::partition(adl_begin(Range), adl_end(Range), P);
1653}
1654 
1655/// Provide wrappers to std::lower_bound which take ranges instead of having to
1656/// pass begin/end explicitly.
1657template <typename R, typename T> auto lower_bound(R &&Range, T &&Value) {
1658  return std::lower_bound(adl_begin(Range), adl_end(Range),
1659                          std::forward<T>(Value));
1660}
1661 
1662template <typename R, typename T, typename Compare>
1663auto lower_bound(R &&Range, T &&Value, Compare C) {
1664  return std::lower_bound(adl_begin(Range), adl_end(Range),
1665                          std::forward<T>(Value), C);
1666}
1667 
1668/// Provide wrappers to std::upper_bound which take ranges instead of having to
1669/// pass begin/end explicitly.
1670template <typename R, typename T> auto upper_bound(R &&Range, T &&Value) {
1671  return std::upper_bound(adl_begin(Range), adl_end(Range),
1672                          std::forward<T>(Value));
1673}
1674 
1675template <typename R, typename T, typename Compare>
1676auto upper_bound(R &&Range, T &&Value, Compare C) {
1677  return std::upper_bound(adl_begin(Range), adl_end(Range),
1678                          std::forward<T>(Value), C);
1679}
1680 
1681template <typename R>
1682void stable_sort(R &&Range) {
1683  std::stable_sort(adl_begin(Range), adl_end(Range));
1684}
1685 
1686template <typename R, typename Compare>
1687void stable_sort(R &&Range, Compare C) {
1688  std::stable_sort(adl_begin(Range), adl_end(Range), C);
1689}
1690 
1691/// Binary search for the first iterator in a range where a predicate is false.
1692/// Requires that C is always true below some limit, and always false above it.
1693template <typename R, typename Predicate,
1694          typename Val = decltype(*adl_begin(std::declval<R>()))>
1695auto partition_point(R &&Range, Predicate P) {
1696  return std::partition_point(adl_begin(Range), adl_end(Range), P);
1697}
1698 
1699template<typename Range, typename Predicate>
1700auto unique(Range &&R, Predicate P) {
1701  return std::unique(adl_begin(R), adl_end(R), P);
1702}
1703 
1704/// Wrapper function around std::equal to detect if pair-wise elements between
1705/// two ranges are the same.
1706template <typename L, typename R> bool equal(L &&LRange, R &&RRange) {
1707  return std::equal(adl_begin(LRange), adl_end(LRange), adl_begin(RRange),
1708                    adl_end(RRange));
1709}
1710 
1711/// Wrapper function around std::equal to detect if all elements
1712/// in a container are same.
1713template <typename R>
1714bool is_splat(R &&Range) {
1715  size_t range_size = size(Range);
1716  return range_size != 0 && (range_size == 1 ||
1717         std::equal(adl_begin(Range) + 1, adl_end(Range), adl_begin(Range)));
1718}
1719 
1720/// Provide a container algorithm similar to C++ Library Fundamentals v2's
1721/// `erase_if` which is equivalent to:
1722///
1723///   C.erase(remove_if(C, pred), C.end());
1724///
1725/// This version works for any container with an erase method call accepting
1726/// two iterators.
1727template <typename Container, typename UnaryPredicate>
1728void erase_if(Container &C, UnaryPredicate P) {
1729  C.erase(remove_if(C, P), C.end());
1730}
1731 
1732/// Wrapper function to remove a value from a container:
1733///
1734/// C.erase(remove(C.begin(), C.end(), V), C.end());
1735template <typename Container, typename ValueType>
1736void erase_value(Container &C, ValueType V) {
1737  C.erase(std::remove(C.begin(), C.end(), V), C.end());
1738}
1739 
1740/// Wrapper function to append a range to a container.
1741///
1742/// C.insert(C.end(), R.begin(), R.end());
1743template <typename Container, typename Range>
1744inline void append_range(Container &C, Range &&R) {
1745  C.insert(C.end(), R.begin(), R.end());
1746}
1747 
1748/// Given a sequence container Cont, replace the range [ContIt, ContEnd) with
1749/// the range [ValIt, ValEnd) (which is not from the same container).
1750template<typename Container, typename RandomAccessIterator>
1751void replace(Container &Cont, typename Container::iterator ContIt,
1752             typename Container::iterator ContEnd, RandomAccessIterator ValIt,
1753             RandomAccessIterator ValEnd) {
1754  while (true) {
1755    if (ValIt == ValEnd) {
1756      Cont.erase(ContIt, ContEnd);
1757      return;
1758    } else if (ContIt == ContEnd) {
1759      Cont.insert(ContIt, ValIt, ValEnd);
1760      return;
1761    }
1762    *ContIt++ = *ValIt++;
1763  }
1764}
1765 
1766/// Given a sequence container Cont, replace the range [ContIt, ContEnd) with
1767/// the range R.
1768template<typename Container, typename Range = std::initializer_list<
1769                                 typename Container::value_type>>
1770void replace(Container &Cont, typename Container::iterator ContIt,
1771             typename Container::iterator ContEnd, Range R) {
1772  replace(Cont, ContIt, ContEnd, R.begin(), R.end());
1773}
1774 
1775/// An STL-style algorithm similar to std::for_each that applies a second
1776/// functor between every pair of elements.
1777///
1778/// This provides the control flow logic to, for example, print a
1779/// comma-separated list:
1780/// \code
1781///   interleave(names.begin(), names.end(),
1782///              [&](StringRef name) { os << name; },
1783///              [&] { os << ", "; });
1784/// \endcode
1785template <typename ForwardIterator, typename UnaryFunctor,
1786          typename NullaryFunctor,
1787          typename = typename std::enable_if<
1788              !std::is_constructible<StringRef, UnaryFunctor>::value &&
1789              !std::is_constructible<StringRef, NullaryFunctor>::value>::type>
1790inline void interleave(ForwardIterator begin, ForwardIterator end,
1791                       UnaryFunctor each_fn, NullaryFunctor between_fn) {
1792  if (begin == end)
1793    return;
1794  each_fn(*begin);
1795  ++begin;
1796  for (; begin != end; ++begin) {
1797    between_fn();
1798    each_fn(*begin);
1799  }
1800}
1801 
1802template <typename Container, typename UnaryFunctor, typename NullaryFunctor,
1803          typename = typename std::enable_if<
1804              !std::is_constructible<StringRef, UnaryFunctor>::value &&
1805              !std::is_constructible<StringRef, NullaryFunctor>::value>::type>
1806inline void interleave(const Container &c, UnaryFunctor each_fn,
1807                       NullaryFunctor between_fn) {
1808  interleave(c.begin(), c.end(), each_fn, between_fn);
1809}
1810 
1811/// Overload of interleave for the common case of string separator.
1812template <typename Container, typename UnaryFunctor, typename StreamT,
1813          typename T = detail::ValueOfRange<Container>>
1814inline void interleave(const Container &c, StreamT &os, UnaryFunctor each_fn,
1815                       const StringRef &separator) {
1816  interleave(c.begin(), c.end(), each_fn, [&] { os << separator; });
1817}
1818template <typename Container, typename StreamT,
1819          typename T = detail::ValueOfRange<Container>>
1820inline void interleave(const Container &c, StreamT &os,
1821                       const StringRef &separator) {
1822  interleave(
1823      c, os, [&](const T &a) { os << a; }, separator);
1824}
1825 
1826template <typename Container, typename UnaryFunctor, typename StreamT,
1827          typename T = detail::ValueOfRange<Container>>
1828inline void interleaveComma(const Container &c, StreamT &os,
1829                            UnaryFunctor each_fn) {
1830  interleave(c, os, each_fn, ", ");
1831}
1832template <typename Container, typename StreamT,
1833          typename T = detail::ValueOfRange<Container>>
1834inline void interleaveComma(const Container &c, StreamT &os) {
1835  interleaveComma(c, os, [&](const T &a) { os << a; });
1836}
1837 
1838//===----------------------------------------------------------------------===//
1839//     Extra additions to <memory>
1840//===----------------------------------------------------------------------===//
1841 
1842struct FreeDeleter {
1843  void operator()(void* v) {
1844    ::free(v);
1845  }
1846};
1847 
1848template<typename First, typename Second>
1849struct pair_hash {
1850  size_t operator()(const std::pair<First, Second> &P) const {
1851    return std::hash<First>()(P.first) * 31 + std::hash<Second>()(P.second);
1852  }
1853};
1854 
1855/// Binary functor that adapts to any other binary functor after dereferencing
1856/// operands.
1857template <typename T> struct deref {
1858  T func;
1859 
1860  // Could be further improved to cope with non-derivable functors and
1861  // non-binary functors (should be a variadic template member function
1862  // operator()).
1863  template <typename A, typename B> auto operator()(A &lhs, B &rhs) const {
1864    assert(lhs)(static_cast<void> (0));
1865    assert(rhs)(static_cast<void> (0));
1866    return func(*lhs, *rhs);
1867  }
1868};
1869 
1870namespace detail {
1871 
1872template <typename R> class enumerator_iter;
1873 
1874template <typename R> struct result_pair {
1875  using value_reference =
1876      typename std::iterator_traits<IterOfRange<R>>::reference;
1877 
1878  friend class enumerator_iter<R>;
1879 
1880  result_pair() = default;
1881  result_pair(std::size_t Index, IterOfRange<R> Iter)
1882      : Index(Index), Iter(Iter) {}
1883 
1884  result_pair(const result_pair<R> &Other)
1885      : Index(Other.Index), Iter(Other.Iter) {}
1886  result_pair &operator=(const result_pair &Other) {
1887    Index = Other.Index;
1888    Iter = Other.Iter;
1889    return *this;
1890  }
1891 
1892  std::size_t index() const { return Index; }
1893  const value_reference value() const { return *Iter; }
1894  value_reference value() { return *Iter; }
1895 
1896private:
1897  std::size_t Index = std::numeric_limits<std::size_t>::max();
1898  IterOfRange<R> Iter;
1899};
1900 
1901template <typename R>
1902class enumerator_iter
1903    : public iterator_facade_base<
1904          enumerator_iter<R>, std::forward_iterator_tag, result_pair<R>,
1905          typename std::iterator_traits<IterOfRange<R>>::difference_type,
1906          typename std::iterator_traits<IterOfRange<R>>::pointer,
1907          typename std::iterator_traits<IterOfRange<R>>::reference> {
1908  using result_type = result_pair<R>;
1909 
1910public:
1911  explicit enumerator_iter(IterOfRange<R> EndIter)
1912      : Result(std::numeric_limits<size_t>::max(), EndIter) {}
1913 
1914  enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
1915      : Result(Index, Iter) {}
1916 
1917  result_type &operator*() { return Result; }
1918  const result_type &operator*() const { return Result; }
1919 
1920  enumerator_iter &operator++() {
1921    assert(Result.Index != std::numeric_limits<size_t>::max())(static_cast<void> (0));
1922    ++Result.Iter;
1923    ++Result.Index;
1924    return *this;
1925  }
1926 
1927  bool operator==(const enumerator_iter &RHS) const {
1928    // Don't compare indices here, only iterators.  It's possible for an end
1929    // iterator to have different indices depending on whether it was created
1930    // by calling std::end() versus incrementing a valid iterator.
1931    return Result.Iter == RHS.Result.Iter;
1932  }
1933 
1934  enumerator_iter(const enumerator_iter &Other) : Result(Other.Result) {}
1935  enumerator_iter &operator=(const enumerator_iter &Other) {
1936    Result = Other.Result;
1937    return *this;
1938  }
1939 
1940private:
1941  result_type Result;
1942};
1943 
1944template <typename R> class enumerator {
1945public:
1946  explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
1947 
1948  enumerator_iter<R> begin() {
1949    return enumerator_iter<R>(0, std::begin(TheRange));
1950  }
1951 
1952  enumerator_iter<R> end() {
1953    return enumerator_iter<R>(std::end(TheRange));
1954  }
1955 
1956private:
1957  R TheRange;
1958};
1959 
1960} // end namespace detail
1961 
1962/// Given an input range, returns a new range whose values are are pair (A,B)
1963/// such that A is the 0-based index of the item in the sequence, and B is
1964/// the value from the original sequence.  Example:
1965///
1966/// std::vector<char> Items = {'A', 'B', 'C', 'D'};
1967/// for (auto X : enumerate(Items)) {
1968///   printf("Item %d - %c\n", X.index(), X.value());
1969/// }
1970///
1971/// Output:
1972///   Item 0 - A
1973///   Item 1 - B
1974///   Item 2 - C
1975///   Item 3 - D
1976///
1977template <typename R> detail::enumerator<R> enumerate(R &&TheRange) {
1978  return detail::enumerator<R>(std::forward<R>(TheRange));
1979}
1980 
1981namespace detail {
1982 
1983template <typename F, typename Tuple, std::size_t... I>
1984decltype(auto) apply_tuple_impl(F &&f, Tuple &&t, std::index_sequence<I...>) {
1985  return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
1986}
1987 
1988} // end namespace detail
1989 
1990/// Given an input tuple (a1, a2, ..., an), pass the arguments of the
1991/// tuple variadically to f as if by calling f(a1, a2, ..., an) and
1992/// return the result.
1993template <typename F, typename Tuple>
1994decltype(auto) apply_tuple(F &&f, Tuple &&t) {
1995  using Indices = std::make_index_sequence<
1996      std::tuple_size<typename std::decay<Tuple>::type>::value>;
1997 
1998  return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
1999                                  Indices{});
2000}
2001 
2002namespace detail {
2003 
2004template <typename Predicate, typename... Args>
2005bool all_of_zip_predicate_first(Predicate &&P, Args &&...args) {
2006  auto z = zip(args...);
2007  auto it = z.begin();
2008  auto end = z.end();
2009  while (it != end) {
2010    if (!apply_tuple([&](auto &&...args) { return P(args...); }, *it))
2011      return false;
2012    ++it;
2013  }
2014  return it.all_equals(end);
2015}
2016 
2017// Just an adaptor to switch the order of argument and have the predicate before
2018// the zipped inputs.
2019template <typename... ArgsThenPredicate, size_t... InputIndexes>
2020bool all_of_zip_predicate_last(
2021    std::tuple<ArgsThenPredicate...> argsThenPredicate,
2022    std::index_sequence<InputIndexes...>) {
2023  auto constexpr OutputIndex =
2024      std::tuple_size<decltype(argsThenPredicate)>::value - 1;
2025  return all_of_zip_predicate_first(std::get<OutputIndex>(argsThenPredicate),
2026                             std::get<InputIndexes>(argsThenPredicate)...);
2027}
2028 
2029} // end namespace detail
2030 
2031/// Compare two zipped ranges using the provided predicate (as last argument).
2032/// Return true if all elements satisfy the predicate and false otherwise.
2033//  Return false if the zipped iterator aren't all at end (size mismatch).
2034template <typename... ArgsAndPredicate>
2035bool all_of_zip(ArgsAndPredicate &&...argsAndPredicate) {
2036  return detail::all_of_zip_predicate_last(
2037      std::forward_as_tuple(argsAndPredicate...),
2038      std::make_index_sequence<sizeof...(argsAndPredicate) - 1>{});
2039}
2040 
2041/// Return true if the sequence [Begin, End) has exactly N items. Runs in O(N)
2042/// time. Not meant for use with random-access iterators.
2043/// Can optionally take a predicate to filter lazily some items.
2044template <typename IterTy,
2045          typename Pred = bool (*)(const decltype(*std::declval<IterTy>()) &)>
2046bool hasNItems(
2047    IterTy &&Begin, IterTy &&End, unsigned N,
2048    Pred &&ShouldBeCounted =
2049        [](const decltype(*std::declval<IterTy>()) &) { return true; },
2050    std::enable_if_t<
2051        !std::is_base_of<std::random_access_iterator_tag,
2052                         typename std::iterator_traits<std::remove_reference_t<
2053                             decltype(Begin)>>::iterator_category>::value,
2054        void> * = nullptr) {
2055  for (; N; ++Begin) {
2056    if (Begin == End)
2057      return false; // Too few.
2058    N -= ShouldBeCounted(*Begin);
2059  }
2060  for (; Begin != End; ++Begin)
2061    if (ShouldBeCounted(*Begin))
2062      return false; // Too many.
2063  return true;
2064}
2065 
2066/// Return true if the sequence [Begin, End) has N or more items. Runs in O(N)
2067/// time. Not meant for use with random-access iterators.
2068/// Can optionally take a predicate to lazily filter some items.
2069template <typename IterTy,
2070          typename Pred = bool (*)(const decltype(*std::declval<IterTy>()) &)>
2071bool hasNItemsOrMore(
2072    IterTy &&Begin, IterTy &&End, unsigned N,
2073    Pred &&ShouldBeCounted =
2074        [](const decltype(*std::declval<IterTy>()) &) { return true; },
2075    std::enable_if_t<
2076        !std::is_base_of<std::random_access_iterator_tag,
2077                         typename std::iterator_traits<std::remove_reference_t<
2078                             decltype(Begin)>>::iterator_category>::value,
2079        void> * = nullptr) {
2080  for (; N; ++Begin) {
2081    if (Begin == End)
2082      return false; // Too few.
2083    N -= ShouldBeCounted(*Begin);
2084  }
2085  return true;
2086}
2087 
2088/// Returns true if the sequence [Begin, End) has N or less items. Can
2089/// optionally take a predicate to lazily filter some items.
2090template <typename IterTy,
2091          typename Pred = bool (*)(const decltype(*std::declval<IterTy>()) &)>
2092bool hasNItemsOrLess(
2093    IterTy &&Begin, IterTy &&End, unsigned N,
2094    Pred &&ShouldBeCounted = [](const decltype(*std::declval<IterTy>()) &) {
2095      return true;
2096    }) {
2097  assert(N != std::numeric_limits<unsigned>::max())(static_cast<void> (0));
2098  return !hasNItemsOrMore(Begin, End, N + 1, ShouldBeCounted);
2099}
2100 
2101/// Returns true if the given container has exactly N items
2102template <typename ContainerTy> bool hasNItems(ContainerTy &&C, unsigned N) {
2103  return hasNItems(std::begin(C), std::end(C), N);
2104}
2105 
2106/// Returns true if the given container has N or more items
2107template <typename ContainerTy>
2108bool hasNItemsOrMore(ContainerTy &&C, unsigned N) {
2109  return hasNItemsOrMore(std::begin(C), std::end(C), N);
2110}
2111 
2112/// Returns true if the given container has N or less items
2113template <typename ContainerTy>
2114bool hasNItemsOrLess(ContainerTy &&C, unsigned N) {
2115  return hasNItemsOrLess(std::begin(C), std::end(C), N);
2116}
2117 
2118/// Returns a raw pointer that represents the same address as the argument.
2119///
2120/// This implementation can be removed once we move to C++20 where it's defined
2121/// as std::to_address().
2122///
2123/// The std::pointer_traits<>::to_address(p) variations of these overloads has
2124/// not been implemented.
2125template <class Ptr> auto to_address(const Ptr &P) { return P.operator->(); }
2126template <class T> constexpr T *to_address(T *P) { return P; }
2127 
2128} // end namespace llvm
2129 
2130#endif // LLVM_ADT_STLEXTRAS_H

←

/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/stl_algo.h

1// Algorithm implementation -*- C++ -*-

3// Copyright (C) 2001-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*/

51/** @file bits/stl_algo.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{algorithm}
*/

56#ifndef _STL_ALGO_H1
57#define _STL_ALGO_H1 1

59#include <cstdlib>	     // for rand
60#include <bits/algorithmfwd.h>
61#include <bits/stl_heap.h>
62#include <bits/stl_tempbuf.h>  // for _Temporary_buffer
63#include <bits/predefined_ops.h>

65#if __cplusplus201402L >= 201103L
66#include <bits/uniform_int_dist.h>
67#endif

69// See concept_check.h for the __glibcxx_*_requires macros.

71namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
72{
73_GLIBCXX_BEGIN_NAMESPACE_VERSION

/// Swaps the median value of *__a, *__b and *__c under __comp to *__result
template<typename _Iterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
	   _Iterator __c, _Compare __comp)
  {
    if (__comp(__a, __b))
{
 if (__comp(__b, __c))
   std::iter_swap(__result, __b);
 else if (__comp(__a, __c))
   std::iter_swap(__result, __c);
 else
   std::iter_swap(__result, __a);
}
    else if (__comp(__a, __c))
std::iter_swap(__result, __a);
    else if (__comp(__b, __c))
std::iter_swap(__result, __c);
    else
std::iter_swap(__result, __b);
  }

/// Provided for stable_partition to use.
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _InputIterator
  __find_if_not(_InputIterator __first, _InputIterator __last,
  _Predicate __pred)
  {
    return std::__find_if(__first, __last,
	    __gnu_cxx::__ops::__negate(__pred),
	    std::__iterator_category(__first));
  }

/// Like find_if_not(), but uses and updates a count of the
/// remaining range length instead of comparing against an end
/// iterator.
template<typename _InputIterator, typename _Predicate, typename _Distance>
  _GLIBCXX20_CONSTEXPR
  _InputIterator
  __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
  {
    for (; __len; --__len,  (void) ++__first)
if (!__pred(__first))
 break;
    return __first;
  }

// set_difference
// set_intersection
// set_symmetric_difference
// set_union
// for_each
// find
// find_if
// find_first_of
// adjacent_find
// count
// count_if
// search

template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator1
  __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    _BinaryPredicate  __predicate)
  {
    // Test for empty ranges
    if (__first1 == __last1 || __first2 == __last2)
return __first1;

    // Test for a pattern of length 1.
    _ForwardIterator2 __p1(__first2);
    if (++__p1 == __last2)
return std::__find_if(__first1, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));

    // General case.
    _ForwardIterator1 __current = __first1;

    for (;;)
{
 __first1 =
   std::__find_if(__first1, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));

 if (__first1 == __last1)
   return __last1;

 _ForwardIterator2 __p = __p1;
 __current = __first1;
 if (++__current == __last1)
   return __last1;

 while (__predicate(__current, __p))
   {
     if (++__p == __last2)
return __first1;
     if (++__current == __last1)
return __last1;
   }
 ++__first1;
}
    return __first1;
  }

// search_n

/**
 *  This is an helper function for search_n overloaded for forward iterators.
*/
template<typename _ForwardIterator, typename _Integer,
  typename _UnaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
   _Integer __count, _UnaryPredicate __unary_pred,
   std::forward_iterator_tag)
  {
    __first = std::__find_if(__first, __last, __unary_pred);
    while (__first != __last)
{
 typename iterator_traits<_ForwardIterator>::difference_type
   __n = __count;
 _ForwardIterator __i = __first;
 ++__i;
 while (__i != __last && __n != 1 && __unary_pred(__i))
   {
     ++__i;
     --__n;
   }
 if (__n == 1)
   return __first;
 if (__i == __last)
   return __last;
 __first = std::__find_if(++__i, __last, __unary_pred);
}
    return __last;
  }

/**
 *  This is an helper function for search_n overloaded for random access
 *  iterators.
*/
template<typename _RandomAccessIter, typename _Integer,
  typename _UnaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _RandomAccessIter
  __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
   _Integer __count, _UnaryPredicate __unary_pred,
   std::random_access_iterator_tag)
  {
    typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
_DistanceType;

    _DistanceType __tailSize = __last - __first;
    _DistanceType __remainder = __count;

    while (__remainder <= __tailSize) // the main loop...
{
 __first += __remainder;
 __tailSize -= __remainder;
 // __first here is always pointing to one past the last element of
 // next possible match.
 _RandomAccessIter __backTrack = __first; 
 while (__unary_pred(--__backTrack))
   {
     if (--__remainder == 0)
return (__first - __count); // Success
   }
 __remainder = __count + 1 - (__first - __backTrack);
}
    return __last; // Failure
  }

template<typename _ForwardIterator, typename _Integer,
  typename _UnaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count,
      _UnaryPredicate __unary_pred)
  {
    if (__count <= 0)
return __first;

    if (__count == 1)
return std::__find_if(__first, __last, __unary_pred);

    return std::__search_n_aux(__first, __last, __count, __unary_pred,
		 std::__iterator_category(__first));
  }

// find_end for forward iterators.
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator1
  __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
      forward_iterator_tag, forward_iterator_tag,
      _BinaryPredicate __comp)
  {
    if (__first2 == __last2)
return __last1;

    _ForwardIterator1 __result = __last1;
    while (1)
{
 _ForwardIterator1 __new_result
   = std::__search(__first1, __last1, __first2, __last2, __comp);
 if (__new_result == __last1)
   return __result;
 else
   {
     __result = __new_result;
     __first1 = __new_result;
     ++__first1;
   }
}
  }

// find_end for bidirectional iterators (much faster).
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _BidirectionalIterator1
  __find_end(_BidirectionalIterator1 __first1,
      _BidirectionalIterator1 __last1,
      _BidirectionalIterator2 __first2,
      _BidirectionalIterator2 __last2,
      bidirectional_iterator_tag, bidirectional_iterator_tag,
      _BinaryPredicate __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator1>)
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator2>)

    typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
    typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;

    _RevIterator1 __rlast1(__first1);
    _RevIterator2 __rlast2(__first2);
    _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
			      _RevIterator2(__last2), __rlast2,
			      __comp);

    if (__rresult == __rlast1)
return __last1;
    else
{
 _BidirectionalIterator1 __result = __rresult.base();
 std::advance(__result, -std::distance(__first2, __last2));
 return __result;
}
  }

/**
 *  @brief  Find last matching subsequence in a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of range to search.
 *  @param  __last1   End of range to search.
 *  @param  __first2  Start of sequence to match.
 *  @param  __last2   End of sequence to match.
 *  @return   The last iterator @c i in the range
 *  @p [__first1,__last1-(__last2-__first2)) such that @c *(i+N) ==
 *  @p *(__first2+N) for each @c N in the range @p
 *  [0,__last2-__first2), or @p __last1 if no such iterator exists.
 *
 *  Searches the range @p [__first1,__last1) for a sub-sequence that
 *  compares equal value-by-value with the sequence given by @p
 *  [__first2,__last2) and returns an iterator to the __first
 *  element of the sub-sequence, or @p __last1 if the sub-sequence
 *  is not found.  The sub-sequence will be the last such
 *  subsequence contained in [__first1,__last1).
 *
 *  Because the sub-sequence must lie completely within the range @p
 *  [__first1,__last1) it must start at a position less than @p
 *  __last1-(__last2-__first2) where @p __last2-__first2 is the
 *  length of the sub-sequence.  This means that the returned
 *  iterator @c i will be in the range @p
 *  [__first1,__last1-(__last2-__first2))
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator1
  find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__find_end(__first1, __last1, __first2, __last2,
	     std::__iterator_category(__first1),
	     std::__iterator_category(__first2),
	     __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief  Find last matching subsequence in a sequence using a predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of range to search.
 *  @param  __last1   End of range to search.
 *  @param  __first2  Start of sequence to match.
 *  @param  __last2   End of sequence to match.
 *  @param  __comp    The predicate to use.
 *  @return The last iterator @c i in the range @p
 *  [__first1,__last1-(__last2-__first2)) such that @c
 *  predicate(*(i+N), @p (__first2+N)) is true for each @c N in the
 *  range @p [0,__last2-__first2), or @p __last1 if no such iterator
 *  exists.
 *
 *  Searches the range @p [__first1,__last1) for a sub-sequence that
 *  compares equal value-by-value with the sequence given by @p
 *  [__first2,__last2) using comp as a predicate and returns an
 *  iterator to the first element of the sub-sequence, or @p __last1
 *  if the sub-sequence is not found.  The sub-sequence will be the
 *  last such subsequence contained in [__first,__last1).
 *
 *  Because the sub-sequence must lie completely within the range @p
 *  [__first1,__last1) it must start at a position less than @p
 *  __last1-(__last2-__first2) where @p __last2-__first2 is the
 *  length of the sub-sequence.  This means that the returned
 *  iterator @c i will be in the range @p
 *  [__first1,__last1-(__last2-__first2))
*/
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator1
  find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    _BinaryPredicate __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__find_end(__first1, __last1, __first2, __last2,
	     std::__iterator_category(__first1),
	     std::__iterator_category(__first2),
	     __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

436#if __cplusplus201402L >= 201103L
/**
 *  @brief  Checks that a predicate is true for all the elements
 *          of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __pred    A predicate.
 *  @return  True if the check is true, false otherwise.
 *
 *  Returns true if @p __pred is true for each element in the range
 *  @p [__first,__last), and false otherwise.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
  { return __last == std::find_if_not(__first, __last, __pred); }

/**
 *  @brief  Checks that a predicate is false for all the elements
 *          of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __pred    A predicate.
 *  @return  True if the check is true, false otherwise.
 *
 *  Returns true if @p __pred is false for each element in the range
 *  @p [__first,__last), and false otherwise.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
  { return __last == _GLIBCXX_STD_Astd::find_if(__first, __last, __pred); }
10
←
Assuming the condition is false→
11
←
Returning zero, which participates in a condition later→

/**
 *  @brief  Checks that a predicate is true for at least one element
 *          of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __pred    A predicate.
 *  @return  True if the check is true, false otherwise.
 *
 *  Returns true if an element exists in the range @p
 *  [__first,__last) such that @p __pred is true, and false
 *  otherwise.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
  { return !std::none_of(__first, __last, __pred); }
9
←
Calling 'none_of<const unsigned long *, (lambda at /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/ADT/BitVector.h:163:25)>'→
12
←
Returning from 'none_of<const unsigned long *, (lambda at /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/ADT/BitVector.h:163:25)>'→
13
←
Returning the value 1, which participates in a condition later→

/**
 *  @brief  Find the first element in a sequence for which a
 *          predicate is false.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __pred   A predicate.
 *  @return   The first iterator @c i in the range @p [__first,__last)
 *  such that @p __pred(*i) is false, or @p __last if no such iterator exists.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _InputIterator
  find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    return std::__find_if_not(__first, __last,
		__gnu_cxx::__ops::__pred_iter(__pred));
  }

/**
 *  @brief  Checks whether the sequence is partitioned.
 *  @ingroup mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __pred   A predicate.
 *  @return  True if the range @p [__first,__last) is partioned by @p __pred,
 *  i.e. if all elements that satisfy @p __pred appear before those that
 *  do not.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_partitioned(_InputIterator __first, _InputIterator __last,
   _Predicate __pred)
  {
    __first = std::find_if_not(__first, __last, __pred);
    if (__first == __last)
return true;
    ++__first;
    return std::none_of(__first, __last, __pred);
  }

/**
 *  @brief  Find the partition point of a partitioned range.
 *  @ingroup mutating_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __pred    A predicate.
 *  @return  An iterator @p mid such that @p all_of(__first, mid, __pred)
 *           and @p none_of(mid, __last, __pred) are both true.
*/
template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  partition_point(_ForwardIterator __first, _ForwardIterator __last,
    _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     typename iterator_traits<_ForwardIterator>::value_type>)

    // A specific debug-mode test will be necessary...
    __glibcxx_requires_valid_range(__first, __last);

    typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

    _DistanceType __len = std::distance(__first, __last);

    while (__len > 0)
{
 _DistanceType __half = __len >> 1;
 _ForwardIterator __middle = __first;
 std::advance(__middle, __half);
 if (__pred(*__middle))
   {
     __first = __middle;
     ++__first;
     __len = __len - __half - 1;
   }
 else
   __len = __half;
}
    return __first;
  }
584#endif

template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __remove_copy_if(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Predicate __pred)
  {
    for (; __first != __last; ++__first)
if (!__pred(__first))
 {
   *__result = *__first;
   ++__result;
 }
    return __result;
  }

/**
 *  @brief Copy a sequence, removing elements of a given value.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __result  An output iterator.
 *  @param  __value   The value to be removed.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) not equal
 *  to @p __value to the range beginning at @p __result.
 *  remove_copy() is stable, so the relative order of elements that
 *  are copied is unchanged.
*/
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  remove_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, const _Tp& __value)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_InputIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__remove_copy_if(__first, __last, __result,
__gnu_cxx::__ops::__iter_equals_val(__value));
  }

/**
 *  @brief Copy a sequence, removing elements for which a predicate is true.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __result  An output iterator.
 *  @param  __pred    A predicate.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) for which
 *  @p __pred returns false to the range beginning at @p __result.
 *
 *  remove_copy_if() is stable, so the relative order of elements that are
 *  copied is unchanged.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  remove_copy_if(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result, _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__remove_copy_if(__first, __last, __result,
		   __gnu_cxx::__ops::__pred_iter(__pred));
  }

668#if __cplusplus201402L >= 201103L
/**
 *  @brief Copy the elements of a sequence for which a predicate is true.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __result  An output iterator.
 *  @param  __pred    A predicate.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) for which
 *  @p __pred returns true to the range beginning at @p __result.
 *
 *  copy_if() is stable, so the relative order of elements that are
 *  copied is unchanged.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  copy_if(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result, _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first)
if (__pred(*__first))
 {
   *__result = *__first;
   ++__result;
 }
    return __result;
  }

template<typename _InputIterator, typename _Size, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result)
  {
    if (__n > 0)
{
 while (true)
   {
     *__result = *__first;
     ++__result;
     if (--__n > 0)
++__first;
     else
break;
   }
}
    return __result;
  }

template<typename _CharT, typename _Size>
  __enable_if_t<__is_char<_CharT>::__value, _CharT*>
  __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT>>,
      _Size, _CharT*);

template<typename _InputIterator, typename _Size, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __copy_n(_InputIterator __first, _Size __n,
    _OutputIterator __result, input_iterator_tag)
  {
    return std::__niter_wrap(__result,
	       __copy_n_a(__first, __n,
			  std::__niter_base(__result)));
  }

template<typename _RandomAccessIterator, typename _Size,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  __copy_n(_RandomAccessIterator __first, _Size __n,
    _OutputIterator __result, random_access_iterator_tag)
  { return std::copy(__first, __first + __n, __result); }

/**
 *  @brief Copies the range [first,first+n) into [result,result+n).
 *  @ingroup mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __n      The number of elements to copy.
 *  @param  __result An output iterator.
 *  @return  result+n.
 *
 *  This inline function will boil down to a call to @c memmove whenever
 *  possible.  Failing that, if random access iterators are passed, then the
 *  loop count will be known (and therefore a candidate for compiler
 *  optimizations such as unrolling).
*/
template<typename _InputIterator, typename _Size, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_can_increment(__first, __n);
    __glibcxx_requires_can_increment(__result, __n);

    return std::__copy_n(__first, __n, __result,
	   std::__iterator_category(__first));
  }

/**
 *  @brief Copy the elements of a sequence to separate output sequences
 *         depending on the truth value of a predicate.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __out_true   An output iterator.
 *  @param  __out_false  An output iterator.
 *  @param  __pred    A predicate.
 *  @return   A pair designating the ends of the resulting sequences.
 *
 *  Copies each element in the range @p [__first,__last) for which
 *  @p __pred returns true to the range beginning at @p out_true
 *  and each element for which @p __pred returns false to @p __out_false.
*/
template<typename _InputIterator, typename _OutputIterator1,
  typename _OutputIterator2, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  pair<_OutputIterator1, _OutputIterator2>
  partition_copy(_InputIterator __first, _InputIterator __last,
   _OutputIterator1 __out_true, _OutputIterator2 __out_false,
   _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator1,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator2,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    
    for (; __first != __last; ++__first)
if (__pred(*__first))
 {
   *__out_true = *__first;
   ++__out_true;
 }
else
 {
   *__out_false = *__first;
   ++__out_false;
 }

    return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
  }
828#endif // C++11

template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
  {
    __first = std::__find_if(__first, __last, __pred);
    if (__first == __last)
return __first;
    _ForwardIterator __result = __first;
    ++__first;
    for (; __first != __last; ++__first)
if (!__pred(__first))
 {
   *__result = _GLIBCXX_MOVE(*__first)std::move(*__first);
   ++__result;
 }
    return __result;
  }

/**
 *  @brief Remove elements from a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __value  The value to be removed.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  All elements equal to @p __value are removed from the range
 *  @p [__first,__last).
 *
 *  remove() is stable, so the relative order of elements that are
 *  not removed is unchanged.
 *
 *  Elements between the end of the resulting sequence and @p __last
 *  are still present, but their value is unspecified.
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  remove(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __value)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__remove_if(__first, __last,
__gnu_cxx::__ops::__iter_equals_val(__value));
  }

/**
 *  @brief Remove elements from a sequence using a predicate.
 *  @ingroup mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @param  __pred   A predicate.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  All elements for which @p __pred returns true are removed from the range
 *  @p [__first,__last).
 *
 *  remove_if() is stable, so the relative order of elements that are
 *  not removed is unchanged.
 *
 *  Elements between the end of the resulting sequence and @p __last
 *  are still present, but their value is unspecified.
*/
template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  remove_if(_ForwardIterator __first, _ForwardIterator __last,
     _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__remove_if(__first, __last,
	      __gnu_cxx::__ops::__pred_iter(__pred));
  }

template<typename _ForwardIterator, typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
  {
    if (__first == __last)
return __last;
    _ForwardIterator __next = __first;
    while (++__next != __last)
{
 if (__binary_pred(__first, __next))
   return __first;
 __first = __next;
}
    return __last;
  }

template<typename _ForwardIterator, typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __unique(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
  {
    // Skip the beginning, if already unique.
    __first = std::__adjacent_find(__first, __last, __binary_pred);
    if (__first == __last)
return __last;

    // Do the real copy work.
    _ForwardIterator __dest = __first;
    ++__first;
    while (++__first != __last)
if (!__binary_pred(__dest, __first))
 *++__dest = _GLIBCXX_MOVE(*__first)std::move(*__first);
    return ++__dest;
  }

/**
 *  @brief Remove consecutive duplicate values from a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @return  An iterator designating the end of the resulting sequence.
 *
 *  Removes all but the first element from each group of consecutive
 *  values that compare equal.
 *  unique() is stable, so the relative order of elements that are
 *  not removed is unchanged.
 *  Elements between the end of the resulting sequence and @p __last
 *  are still present, but their value is unspecified.
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  unique(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_EqualityComparableConcept<
     typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__unique(__first, __last,
	   __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief Remove consecutive values from a sequence using a predicate.
 *  @ingroup mutating_algorithms
 *  @param  __first        A forward iterator.
 *  @param  __last         A forward iterator.
 *  @param  __binary_pred  A binary predicate.
 *  @return  An iterator designating the end of the resulting sequence.
 *
 *  Removes all but the first element from each group of consecutive
 *  values for which @p __binary_pred returns true.
 *  unique() is stable, so the relative order of elements that are
 *  not removed is unchanged.
 *  Elements between the end of the resulting sequence and @p __last
 *  are still present, but their value is unspecified.
*/
template<typename _ForwardIterator, typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  unique(_ForwardIterator __first, _ForwardIterator __last,
  _BinaryPredicate __binary_pred)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
typename iterator_traits<_ForwardIterator>::value_type,
typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__unique(__first, __last,
	   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
  }

/**
 *  This is an uglified
 *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
 *              _BinaryPredicate)
 *  overloaded for forward iterators and output iterator as result.
*/
template<typename _ForwardIterator, typename _OutputIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
  _OutputIterator __result, _BinaryPredicate __binary_pred,
  forward_iterator_tag, output_iterator_tag)
  {
    // concept requirements -- iterators already checked
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
 typename iterator_traits<_ForwardIterator>::value_type,
 typename iterator_traits<_ForwardIterator>::value_type>)

    _ForwardIterator __next = __first;
    *__result = *__first;
    while (++__next != __last)
if (!__binary_pred(__first, __next))
 {
   __first = __next;
   *++__result = *__first;
 }
    return ++__result;
  }

/**
 *  This is an uglified
 *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
 *              _BinaryPredicate)
 *  overloaded for input iterators and output iterator as result.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result, _BinaryPredicate __binary_pred,
  input_iterator_tag, output_iterator_tag)
  {
    // concept requirements -- iterators already checked
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
 typename iterator_traits<_InputIterator>::value_type,
 typename iterator_traits<_InputIterator>::value_type>)

    typename iterator_traits<_InputIterator>::value_type __value = *__first;
    __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
__rebound_pred
= __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
    *__result = __value;
    while (++__first != __last)
if (!__rebound_pred(__first, __value))
 {
   __value = *__first;
   *++__result = __value;
 }
    return ++__result;
  }

/**
 *  This is an uglified
 *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
 *              _BinaryPredicate)
 *  overloaded for input iterators and forward iterator as result.
*/
template<typename _InputIterator, typename _ForwardIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __unique_copy(_InputIterator __first, _InputIterator __last,
  _ForwardIterator __result, _BinaryPredicate __binary_pred,
  input_iterator_tag, forward_iterator_tag)
  {
    // concept requirements -- iterators already checked
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
 typename iterator_traits<_ForwardIterator>::value_type,
 typename iterator_traits<_InputIterator>::value_type>)
    *__result = *__first;
    while (++__first != __last)
if (!__binary_pred(__result, __first))
 *++__result = *__first;
    return ++__result;
  }

/**
 *  This is an uglified reverse(_BidirectionalIterator,
 *                              _BidirectionalIterator)
 *  overloaded for bidirectional iterators.
*/
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  void
  __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
     bidirectional_iterator_tag)
  {
    while (true)
if (__first == __last || __first == --__last)
 return;
else
 {
   std::iter_swap(__first, __last);
   ++__first;
 }
  }

/**
 *  This is an uglified reverse(_BidirectionalIterator,
 *                              _BidirectionalIterator)
 *  overloaded for random access iterators.
*/
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  void
  __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
     random_access_iterator_tag)
  {
    if (__first == __last)
return;
    --__last;
    while (__first < __last)
{
 std::iter_swap(__first, __last);
 ++__first;
 --__last;
}
  }

/**
 *  @brief Reverse a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  A bidirectional iterator.
 *  @param  __last   A bidirectional iterator.
 *  @return   reverse() returns no value.
 *
 *  Reverses the order of the elements in the range @p [__first,__last),
 *  so that the first element becomes the last etc.
 *  For every @c i such that @p 0<=i<=(__last-__first)/2), @p reverse()
 *  swaps @p *(__first+i) and @p *(__last-(i+1))
*/
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  inline void
  reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_requires_valid_range(__first, __last);
    std::__reverse(__first, __last, std::__iterator_category(__first));
  }

/**
 *  @brief Copy a sequence, reversing its elements.
 *  @ingroup mutating_algorithms
 *  @param  __first   A bidirectional iterator.
 *  @param  __last    A bidirectional iterator.
 *  @param  __result  An output iterator.
 *  @return  An iterator designating the end of the resulting sequence.
 *
 *  Copies the elements in the range @p [__first,__last) to the
 *  range @p [__result,__result+(__last-__first)) such that the
 *  order of the elements is reversed.  For every @c i such that @p
 *  0<=i<=(__last-__first), @p reverse_copy() performs the
 *  assignment @p *(__result+(__last-__first)-1-i) = *(__first+i).
 *  The ranges @p [__first,__last) and @p
 *  [__result,__result+(__last-__first)) must not overlap.
*/
template<typename _BidirectionalIterator, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
 _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    while (__first != __last)
{
 --__last;
 *__result = *__last;
 ++__result;
}
    return __result;
  }

/**
 *  This is a helper function for the rotate algorithm specialized on RAIs.
 *  It returns the greatest common divisor of two integer values.
*/
template<typename _EuclideanRingElement>
  _GLIBCXX20_CONSTEXPR
  _EuclideanRingElement
  __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
  {
    while (__n != 0)
{
 _EuclideanRingElement __t = __m % __n;
 __m = __n;
 __n = __t;
}
    return __m;
  }

inline namespace _V2
{

/// This is a helper function for the rotate algorithm.
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __rotate(_ForwardIterator __first,
    _ForwardIterator __middle,
    _ForwardIterator __last,
    forward_iterator_tag)
  {
    if (__first == __middle)
return __last;
    else if (__last == __middle)
return __first;

    _ForwardIterator __first2 = __middle;
    do
{
 std::iter_swap(__first, __first2);
 ++__first;
 ++__first2;
 if (__first == __middle)
   __middle = __first2;
}
    while (__first2 != __last);

    _ForwardIterator __ret = __first;

    __first2 = __middle;

    while (__first2 != __last)
{
 std::iter_swap(__first, __first2);
 ++__first;
 ++__first2;
 if (__first == __middle)
   __middle = __first2;
 else if (__first2 == __last)
   __first2 = __middle;
}
    return __ret;
  }

 /// This is a helper function for the rotate algorithm.
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  _BidirectionalIterator
  __rotate(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last,
     bidirectional_iterator_tag)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)

    if (__first == __middle)
return __last;
    else if (__last == __middle)
return __first;

    std::__reverse(__first,  __middle, bidirectional_iterator_tag());
    std::__reverse(__middle, __last,   bidirectional_iterator_tag());

    while (__first != __middle && __middle != __last)
{
 std::iter_swap(__first, --__last);
 ++__first;
}

    if (__first == __middle)
{
 std::__reverse(__middle, __last,   bidirectional_iterator_tag());
 return __last;
}
    else
{
 std::__reverse(__first,  __middle, bidirectional_iterator_tag());
 return __first;
}
  }

/// This is a helper function for the rotate algorithm.
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  _RandomAccessIterator
  __rotate(_RandomAccessIterator __first,
    _RandomAccessIterator __middle,
    _RandomAccessIterator __last,
    random_access_iterator_tag)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
		  _RandomAccessIterator>)

    if (__first == __middle)
return __last;
    else if (__last == __middle)
return __first;

    typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;
    typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;

    _Distance __n = __last   - __first;
    _Distance __k = __middle - __first;

    if (__k == __n - __k)
{
 std::swap_ranges(__first, __middle, __middle);
 return __middle;
}

    _RandomAccessIterator __p = __first;
    _RandomAccessIterator __ret = __first + (__last - __middle);

    for (;;)
{
 if (__k < __n - __k)
   {
     if (__is_pod(_ValueType) && __k == 1)
{
  _ValueType __t = _GLIBCXX_MOVE(*__p)std::move(*__p);
  _GLIBCXX_MOVE3(__p + 1, __p + __n, __p)std::move(__p + 1, __p + __n, __p);
  *(__p + __n - 1) = _GLIBCXX_MOVE(__t)std::move(__t);
  return __ret;
}
     _RandomAccessIterator __q = __p + __k;
     for (_Distance __i = 0; __i < __n - __k; ++ __i)
{
  std::iter_swap(__p, __q);
  ++__p;
  ++__q;
}
     __n %= __k;
     if (__n == 0)
return __ret;
     std::swap(__n, __k);
     __k = __n - __k;
   }
 else
   {
     __k = __n - __k;
     if (__is_pod(_ValueType) && __k == 1)
{
  _ValueType __t = _GLIBCXX_MOVE(*(__p + __n - 1))std::move(*(__p + __n - 1));
  _GLIBCXX_MOVE_BACKWARD3(__p, __p + __n - 1, __p + __n)std::move_backward(__p, __p + __n - 1, __p + __n);
  *__p = _GLIBCXX_MOVE(__t)std::move(__t);
  return __ret;
}
     _RandomAccessIterator __q = __p + __n;
     __p = __q - __k;
     for (_Distance __i = 0; __i < __n - __k; ++ __i)
{
  --__p;
  --__q;
  std::iter_swap(__p, __q);
}
     __n %= __k;
     if (__n == 0)
return __ret;
     std::swap(__n, __k);
   }
}
  }

 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // DR 488. rotate throws away useful information
/**
 *  @brief Rotate the elements of a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __middle  A forward iterator.
 *  @param  __last    A forward iterator.
 *  @return  first + (last - middle).
 *
 *  Rotates the elements of the range @p [__first,__last) by 
 *  @p (__middle - __first) positions so that the element at @p __middle
 *  is moved to @p __first, the element at @p __middle+1 is moved to
 *  @p __first+1 and so on for each element in the range
 *  @p [__first,__last).
 *
 *  This effectively swaps the ranges @p [__first,__middle) and
 *  @p [__middle,__last).
 *
 *  Performs
 *   @p *(__first+(n+(__last-__middle))%(__last-__first))=*(__first+n)
 *  for each @p n in the range @p [0,__last-__first).
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  rotate(_ForwardIterator __first, _ForwardIterator __middle,
  _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_requires_valid_range(__first, __middle);
    __glibcxx_requires_valid_range(__middle, __last);

    return std::__rotate(__first, __middle, __last,
	   std::__iterator_category(__first));
  }

} // namespace _V2

/**
 *  @brief Copy a sequence, rotating its elements.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __middle  A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __result  An output iterator.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies the elements of the range @p [__first,__last) to the
 *  range beginning at @result, rotating the copied elements by 
 *  @p (__middle-__first) positions so that the element at @p __middle
 *  is moved to @p __result, the element at @p __middle+1 is moved
 *  to @p __result+1 and so on for each element in the range @p
 *  [__first,__last).
 *
 *  Performs 
 *  @p *(__result+(n+(__last-__middle))%(__last-__first))=*(__first+n)
 *  for each @p n in the range @p [0,__last-__first).
*/
template<typename _ForwardIterator, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last, _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __middle);
    __glibcxx_requires_valid_range(__middle, __last);

    return std::copy(__first, __middle,
       std::copy(__middle, __last, __result));
  }

/// This is a helper function...
template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, forward_iterator_tag)
  {
    if (__first == __last)
return __first;

    while (__pred(*__first))
if (++__first == __last)
 return __first;

    _ForwardIterator __next = __first;

    while (++__next != __last)
if (__pred(*__next))
 {
   std::iter_swap(__first, __next);
   ++__first;
 }

    return __first;
  }

/// This is a helper function...
template<typename _BidirectionalIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _BidirectionalIterator
  __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
_Predicate __pred, bidirectional_iterator_tag)
  {
    while (true)
{
 while (true)
   if (__first == __last)
     return __first;
   else if (__pred(*__first))
     ++__first;
   else
     break;
 --__last;
 while (true)
   if (__first == __last)
     return __first;
   else if (!bool(__pred(*__last)))
     --__last;
   else
     break;
 std::iter_swap(__first, __last);
 ++__first;
}
  }

// partition

/// This is a helper function...
/// Requires __first != __last and !__pred(__first)
/// and __len == distance(__first, __last).
///
/// !__pred(__first) allows us to guarantee that we don't
/// move-assign an element onto itself.
template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
  typename _Distance>
  _ForwardIterator
  __stable_partition_adaptive(_ForwardIterator __first,
		_ForwardIterator __last,
		_Predicate __pred, _Distance __len,
		_Pointer __buffer,
		_Distance __buffer_size)
  {
    if (__len == 1)
return __first;

    if (__len <= __buffer_size)
{
 _ForwardIterator __result1 = __first;
 _Pointer __result2 = __buffer;

 // The precondition guarantees that !__pred(__first), so
 // move that element to the buffer before starting the loop.
 // This ensures that we only call __pred once per element.
 *__result2 = _GLIBCXX_MOVE(*__first)std::move(*__first);
 ++__result2;
 ++__first;
 for (; __first != __last; ++__first)
   if (__pred(__first))
     {
*__result1 = _GLIBCXX_MOVE(*__first)std::move(*__first);
++__result1;
     }
   else
     {
*__result2 = _GLIBCXX_MOVE(*__first)std::move(*__first);
++__result2;
     }

 _GLIBCXX_MOVE3(__buffer, __result2, __result1)std::move(__buffer, __result2, __result1);
 return __result1;
}

    _ForwardIterator __middle = __first;
    std::advance(__middle, __len / 2);
    _ForwardIterator __left_split =
std::__stable_partition_adaptive(__first, __middle, __pred,
			 __len / 2, __buffer,
			 __buffer_size);

    // Advance past true-predicate values to satisfy this
    // function's preconditions.
    _Distance __right_len = __len - __len / 2;
    _ForwardIterator __right_split =
std::__find_if_not_n(__middle, __right_len, __pred);

    if (__right_len)
__right_split =
 std::__stable_partition_adaptive(__right_split, __last, __pred,
			   __right_len,
			   __buffer, __buffer_size);

    return std::rotate(__left_split, __middle, __right_split);
  }

template<typename _ForwardIterator, typename _Predicate>
  _ForwardIterator
  __stable_partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
  {
    __first = std::__find_if_not(__first, __last, __pred);

    if (__first == __last)
return __first;

    typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
    typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

    _Temporary_buffer<_ForwardIterator, _ValueType>
__buf(__first, std::distance(__first, __last));
    return
std::__stable_partition_adaptive(__first, __last, __pred,
			 _DistanceType(__buf.requested_size()),
			 __buf.begin(),
			 _DistanceType(__buf.size()));
  }

/**
 *  @brief Move elements for which a predicate is true to the beginning
 *         of a sequence, preserving relative ordering.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __pred    A predicate functor.
 *  @return  An iterator @p middle such that @p __pred(i) is true for each
 *  iterator @p i in the range @p [first,middle) and false for each @p i
 *  in the range @p [middle,last).
 *
 *  Performs the same function as @p partition() with the additional
 *  guarantee that the relative ordering of elements in each group is
 *  preserved, so any two elements @p x and @p y in the range
 *  @p [__first,__last) such that @p __pred(x)==__pred(y) will have the same
 *  relative ordering after calling @p stable_partition().
*/
template<typename _ForwardIterator, typename _Predicate>
  inline _ForwardIterator
  stable_partition(_ForwardIterator __first, _ForwardIterator __last,
     _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__stable_partition(__first, __last,
		     __gnu_cxx::__ops::__pred_iter(__pred));
  }

/// This is a helper function for the sort routines.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __heap_select(_RandomAccessIterator __first,
  _RandomAccessIterator __middle,
  _RandomAccessIterator __last, _Compare __comp)
  {
    std::__make_heap(__first, __middle, __comp);
    for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
if (__comp(__i, __first))
 std::__pop_heap(__first, __middle, __i, __comp);
  }

// partial_sort

template<typename _InputIterator, typename _RandomAccessIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _RandomAccessIterator
  __partial_sort_copy(_InputIterator __first, _InputIterator __last,
	_RandomAccessIterator __result_first,
	_RandomAccessIterator __result_last,
	_Compare __comp)
  {
    typedef typename iterator_traits<_InputIterator>::value_type
_InputValueType;
    typedef iterator_traits<_RandomAccessIterator> _RItTraits;
    typedef typename _RItTraits::difference_type _DistanceType;

    if (__result_first == __result_last)
return __result_last;
    _RandomAccessIterator __result_real_last = __result_first;
    while (__first != __last && __result_real_last != __result_last)
{
 *__result_real_last = *__first;
 ++__result_real_last;
 ++__first;
}
    
    std::__make_heap(__result_first, __result_real_last, __comp);
    while (__first != __last)
{
 if (__comp(__first, __result_first))
   std::__adjust_heap(__result_first, _DistanceType(0),
	       _DistanceType(__result_real_last
			     - __result_first),
	       _InputValueType(*__first), __comp);
 ++__first;
}
    std::__sort_heap(__result_first, __result_real_last, __comp);
    return __result_real_last;
  }

/**
 *  @brief Copy the smallest elements of a sequence.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __result_first   A random-access iterator.
 *  @param  __result_last    Another random-access iterator.
 *  @return   An iterator indicating the end of the resulting sequence.
 *
 *  Copies and sorts the smallest N values from the range @p [__first,__last)
 *  to the range beginning at @p __result_first, where the number of
 *  elements to be copied, @p N, is the smaller of @p (__last-__first) and
 *  @p (__result_last-__result_first).
 *  After the sort if @e i and @e j are iterators in the range
 *  @p [__result_first,__result_first+N) such that i precedes j then
 *  *j<*i is false.
 *  The value returned is @p __result_first+N.
*/
template<typename _InputIterator, typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  inline _RandomAccessIterator
  partial_sort_copy(_InputIterator __first, _InputIterator __last,
      _RandomAccessIterator __result_first,
      _RandomAccessIterator __result_last)
  {
1737#ifdef _GLIBCXX_CONCEPT_CHECKS
    typedef typename iterator_traits<_InputIterator>::value_type
_InputValueType;
    typedef typename iterator_traits<_RandomAccessIterator>::value_type
_OutputValueType;
1742#endif

    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
		  _OutputValueType>)
    __glibcxx_function_requires(_LessThanOpConcept<_InputValueType,
				     _OutputValueType>)
    __glibcxx_function_requires(_LessThanComparableConcept<_OutputValueType>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);
    __glibcxx_requires_valid_range(__result_first, __result_last);

    return std::__partial_sort_copy(__first, __last,
		      __result_first, __result_last,
		      __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Copy the smallest elements of a sequence using a predicate for
 *         comparison.
 *  @ingroup sorting_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    Another input iterator.
 *  @param  __result_first   A random-access iterator.
 *  @param  __result_last    Another random-access iterator.
 *  @param  __comp    A comparison functor.
 *  @return   An iterator indicating the end of the resulting sequence.
 *
 *  Copies and sorts the smallest N values from the range @p [__first,__last)
 *  to the range beginning at @p result_first, where the number of
 *  elements to be copied, @p N, is the smaller of @p (__last-__first) and
 *  @p (__result_last-__result_first).
 *  After the sort if @e i and @e j are iterators in the range
 *  @p [__result_first,__result_first+N) such that i precedes j then
 *  @p __comp(*j,*i) is false.
 *  The value returned is @p __result_first+N.
*/
template<typename _InputIterator, typename _RandomAccessIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _RandomAccessIterator
  partial_sort_copy(_InputIterator __first, _InputIterator __last,
      _RandomAccessIterator __result_first,
      _RandomAccessIterator __result_last,
      _Compare __comp)
  {
1789#ifdef _GLIBCXX_CONCEPT_CHECKS
    typedef typename iterator_traits<_InputIterator>::value_type
_InputValueType;
    typedef typename iterator_traits<_RandomAccessIterator>::value_type
_OutputValueType;
1794#endif

    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
		  _RandomAccessIterator>)
    __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
		  _OutputValueType>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
		  _InputValueType, _OutputValueType>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
		  _OutputValueType, _OutputValueType>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
    __glibcxx_requires_valid_range(__result_first, __result_last);

    return std::__partial_sort_copy(__first, __last,
		      __result_first, __result_last,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __unguarded_linear_insert(_RandomAccessIterator __last,
	      _Compare __comp)
  {
    typename iterator_traits<_RandomAccessIterator>::value_type
__val = _GLIBCXX_MOVE(*__last)std::move(*__last);
    _RandomAccessIterator __next = __last;
    --__next;
    while (__comp(__val, __next))
{
 *__last = _GLIBCXX_MOVE(*__next)std::move(*__next);
 __last = __next;
 --__next;
}
    *__last = _GLIBCXX_MOVE(__val)std::move(__val);
  }

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __insertion_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __last, _Compare __comp)
  {
    if (__first == __last) return;

    for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
{
 if (__comp(__i, __first))
   {
     typename iterator_traits<_RandomAccessIterator>::value_type
__val = _GLIBCXX_MOVE(*__i)std::move(*__i);
     _GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + 1)std::move_backward(__first, __i, __i + 1);
     *__first = _GLIBCXX_MOVE(__val)std::move(__val);
   }
 else
   std::__unguarded_linear_insert(__i,
		__gnu_cxx::__ops::__val_comp_iter(__comp));
}
  }

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  __unguarded_insertion_sort(_RandomAccessIterator __first,
	       _RandomAccessIterator __last, _Compare __comp)
  {
    for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
std::__unguarded_linear_insert(__i,
		__gnu_cxx::__ops::__val_comp_iter(__comp));
  }

/**
 *  @doctodo
 *  This controls some aspect of the sort routines.
*/
enum { _S_threshold = 16 };

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __final_insertion_sort(_RandomAccessIterator __first,
	   _RandomAccessIterator __last, _Compare __comp)
  {
    if (__last - __first > int(_S_threshold))
{
 std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
 std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
			  __comp);
}
    else
std::__insertion_sort(__first, __last, __comp);
  }

/// This is a helper function...
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _RandomAccessIterator
  __unguarded_partition(_RandomAccessIterator __first,
	  _RandomAccessIterator __last,
	  _RandomAccessIterator __pivot, _Compare __comp)
  {
    while (true)
{
 while (__comp(__first, __pivot))
   ++__first;
 --__last;
 while (__comp(__pivot, __last))
   --__last;
 if (!(__first < __last))
   return __first;
 std::iter_swap(__first, __last);
 ++__first;
}
  }

/// This is a helper function...
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _RandomAccessIterator
  __unguarded_partition_pivot(_RandomAccessIterator __first,
		_RandomAccessIterator __last, _Compare __comp)
  {
    _RandomAccessIterator __mid = __first + (__last - __first) / 2;
    std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
		  __comp);
    return std::__unguarded_partition(__first + 1, __last, __first, __comp);
  }

template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  __partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last,
   _Compare __comp)
  {
    std::__heap_select(__first, __middle, __last, __comp);
    std::__sort_heap(__first, __middle, __comp);
  }

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __introsort_loop(_RandomAccessIterator __first,
     _RandomAccessIterator __last,
     _Size __depth_limit, _Compare __comp)
  {
    while (__last - __first > int(_S_threshold))
{
 if (__depth_limit == 0)
   {
     std::__partial_sort(__first, __last, __last, __comp);
     return;
   }
 --__depth_limit;
 _RandomAccessIterator __cut =
   std::__unguarded_partition_pivot(__first, __last, __comp);
 std::__introsort_loop(__cut, __last, __depth_limit, __comp);
 __last = __cut;
}
  }

// sort

template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
  {
    if (__first != __last)
{
 std::__introsort_loop(__first, __last,
		std::__lg(__last - __first) * 2,
		__comp);
 std::__final_insertion_sort(__first, __last, __comp);
}
  }

template<typename _RandomAccessIterator, typename _Size, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
  _RandomAccessIterator __last, _Size __depth_limit,
  _Compare __comp)
  {
    while (__last - __first > 3)
{
 if (__depth_limit == 0)
   {
     std::__heap_select(__first, __nth + 1, __last, __comp);
     // Place the nth largest element in its final position.
     std::iter_swap(__first, __nth);
     return;
   }
 --__depth_limit;
 _RandomAccessIterator __cut =
   std::__unguarded_partition_pivot(__first, __last, __comp);
 if (__cut <= __nth)
   __first = __cut;
 else
   __last = __cut;
}
    std::__insertion_sort(__first, __last, __comp);
  }

// nth_element

// lower_bound moved to stl_algobase.h

/**
 *  @brief Finds the first position in which @p __val could be inserted
 *         without changing the ordering.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @param  __comp    A functor to use for comparisons.
 *  @return An iterator pointing to the first element <em>not less
 *           than</em> @p __val, or end() if every element is less
 *           than @p __val.
 *  @ingroup binary_search_algorithms
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_requires_partitioned_lower_pred(__first, __last,
				__val, __comp);

    return std::__lower_bound(__first, __last, __val,
		__gnu_cxx::__ops::__iter_comp_val(__comp));
  }

template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
  {
    typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

    _DistanceType __len = std::distance(__first, __last);

    while (__len > 0)
{
 _DistanceType __half = __len >> 1;
 _ForwardIterator __middle = __first;
 std::advance(__middle, __half);
 if (__comp(__val, __middle))
   __len = __half;
 else
   {
     __first = __middle;
     ++__first;
     __len = __len - __half - 1;
   }
}
    return __first;
  }

/**
 *  @brief Finds the last position in which @p __val could be inserted
 *         without changing the ordering.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @return  An iterator pointing to the first element greater than @p __val,
 *           or end() if no elements are greater than @p __val.
 *  @ingroup binary_search_algorithms
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanOpConcept<
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_upper(__first, __last, __val);

    return std::__upper_bound(__first, __last, __val,
		__gnu_cxx::__ops::__val_less_iter());
  }

/**
 *  @brief Finds the last position in which @p __val could be inserted
 *         without changing the ordering.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @param  __comp    A functor to use for comparisons.
 *  @return  An iterator pointing to the first element greater than @p __val,
 *           or end() if no elements are greater than @p __val.
 *  @ingroup binary_search_algorithms
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_upper_pred(__first, __last,
				__val, __comp);

    return std::__upper_bound(__first, __last, __val,
		__gnu_cxx::__ops::__val_comp_iter(__comp));
  }

template<typename _ForwardIterator, typename _Tp,
  typename _CompareItTp, typename _CompareTpIt>
  _GLIBCXX20_CONSTEXPR
  pair<_ForwardIterator, _ForwardIterator>
  __equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val,
  _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
  {
    typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

    _DistanceType __len = std::distance(__first, __last);

    while (__len > 0)
{
 _DistanceType __half = __len >> 1;
 _ForwardIterator __middle = __first;
 std::advance(__middle, __half);
 if (__comp_it_val(__middle, __val))
   {
     __first = __middle;
     ++__first;
     __len = __len - __half - 1;
   }
 else if (__comp_val_it(__val, __middle))
   __len = __half;
 else
   {
     _ForwardIterator __left
= std::__lower_bound(__first, __middle, __val, __comp_it_val);
     std::advance(__first, __len);
     _ForwardIterator __right
= std::__upper_bound(++__middle, __first, __val, __comp_val_it);
     return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
   }
}
    return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
  }

/**
 *  @brief Finds the largest subrange in which @p __val could be inserted
 *         at any place in it without changing the ordering.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @return  An pair of iterators defining the subrange.
 *  @ingroup binary_search_algorithms
 *
 *  This is equivalent to
 *  @code
 *    std::make_pair(lower_bound(__first, __last, __val),
 *                   upper_bound(__first, __last, __val))
 *  @endcode
 *  but does not actually call those functions.
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline pair<_ForwardIterator, _ForwardIterator>
  equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanOpConcept<
typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_function_requires(_LessThanOpConcept<
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_lower(__first, __last, __val);
    __glibcxx_requires_partitioned_upper(__first, __last, __val);

    return std::__equal_range(__first, __last, __val,
		__gnu_cxx::__ops::__iter_less_val(),
		__gnu_cxx::__ops::__val_less_iter());
  }

/**
 *  @brief Finds the largest subrange in which @p __val could be inserted
 *         at any place in it without changing the ordering.
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @param  __comp    A functor to use for comparisons.
 *  @return  An pair of iterators defining the subrange.
 *  @ingroup binary_search_algorithms
 *
 *  This is equivalent to
 *  @code
 *    std::make_pair(lower_bound(__first, __last, __val, __comp),
 *                   upper_bound(__first, __last, __val, __comp))
 *  @endcode
 *  but does not actually call those functions.
*/
template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline pair<_ForwardIterator, _ForwardIterator>
  equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_lower_pred(__first, __last,
				__val, __comp);
    __glibcxx_requires_partitioned_upper_pred(__first, __last,
				__val, __comp);

    return std::__equal_range(__first, __last, __val,
		__gnu_cxx::__ops::__iter_comp_val(__comp),
		__gnu_cxx::__ops::__val_comp_iter(__comp));
  }

/**
 *  @brief Determines whether an element exists in a range.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @return True if @p __val (or its equivalent) is in [@p
 *  __first,@p __last ].
 *
 *  Note that this does not actually return an iterator to @p __val.  For
 *  that, use std::find or a container's specialized find member functions.
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  bool
  binary_search(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanOpConcept<
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_lower(__first, __last, __val);
    __glibcxx_requires_partitioned_upper(__first, __last, __val);

    _ForwardIterator __i
= std::__lower_bound(__first, __last, __val,
	     __gnu_cxx::__ops::__iter_less_val());
    return __i != __last && !(__val < *__i);
  }

/**
 *  @brief Determines whether an element exists in a range.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @param  __comp    A functor to use for comparisons.
 *  @return  True if @p __val (or its equivalent) is in @p [__first,__last].
 *
 *  Note that this does not actually return an iterator to @p __val.  For
 *  that, use std::find or a container's specialized find member functions.
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  bool
  binary_search(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_lower_pred(__first, __last,
				__val, __comp);
    __glibcxx_requires_partitioned_upper_pred(__first, __last,
				__val, __comp);

    _ForwardIterator __i
= std::__lower_bound(__first, __last, __val,
	     __gnu_cxx::__ops::__iter_comp_val(__comp));
    return __i != __last && !bool(__comp(__val, *__i));
  }

// merge

/// This is a helper function for the __merge_adaptive routines.
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  void
  __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
	  _InputIterator2 __first2, _InputIterator2 __last2,
	  _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
{
 if (__comp(__first2, __first1))
   {
     *__result = _GLIBCXX_MOVE(*__first2)std::move(*__first2);
     ++__first2;
   }
 else
   {
     *__result = _GLIBCXX_MOVE(*__first1)std::move(*__first1);
     ++__first1;
   }
 ++__result;
}
    if (__first1 != __last1)
_GLIBCXX_MOVE3(__first1, __last1, __result)std::move(__first1, __last1, __result);
  }

/// This is a helper function for the __merge_adaptive routines.
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
  typename _BidirectionalIterator3, typename _Compare>
  void
  __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
		   _BidirectionalIterator1 __last1,
		   _BidirectionalIterator2 __first2,
		   _BidirectionalIterator2 __last2,
		   _BidirectionalIterator3 __result,
		   _Compare __comp)
  {
    if (__first1 == __last1)
{
 _GLIBCXX_MOVE_BACKWARD3(__first2, __last2, __result)std::move_backward(__first2, __last2, __result);
 return;
}
    else if (__first2 == __last2)
return;

    --__last1;
    --__last2;
    while (true)
{
 if (__comp(__last2, __last1))
   {
     *--__result = _GLIBCXX_MOVE(*__last1)std::move(*__last1);
     if (__first1 == __last1)
{
  _GLIBCXX_MOVE_BACKWARD3(__first2, ++__last2, __result)std::move_backward(__first2, ++__last2, __result);
  return;
}
     --__last1;
   }
 else
   {
     *--__result = _GLIBCXX_MOVE(*__last2)std::move(*__last2);
     if (__first2 == __last2)
return;
     --__last2;
   }
}
  }

/// This is a helper function for the merge routines.
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
  typename _Distance>
  _BidirectionalIterator1
  __rotate_adaptive(_BidirectionalIterator1 __first,
      _BidirectionalIterator1 __middle,
      _BidirectionalIterator1 __last,
      _Distance __len1, _Distance __len2,
      _BidirectionalIterator2 __buffer,
      _Distance __buffer_size)
  {
    _BidirectionalIterator2 __buffer_end;
    if (__len1 > __len2 && __len2 <= __buffer_size)
{
 if (__len2)
   {
     __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer)std::move(__middle, __last, __buffer);
     _GLIBCXX_MOVE_BACKWARD3(__first, __middle, __last)std::move_backward(__first, __middle, __last);
     return _GLIBCXX_MOVE3(__buffer, __buffer_end, __first)std::move(__buffer, __buffer_end, __first);
   }
 else
   return __first;
}
    else if (__len1 <= __buffer_size)
{
 if (__len1)
   {
     __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer)std::move(__first, __middle, __buffer);
     _GLIBCXX_MOVE3(__middle, __last, __first)std::move(__middle, __last, __first);
     return _GLIBCXX_MOVE_BACKWARD3(__buffer, __buffer_end, __last)std::move_backward(__buffer, __buffer_end, __last);
   }
 else
   return __last;
}
    else
return std::rotate(__first, __middle, __last);
  }

/// This is a helper function for the merge routines.
template<typename _BidirectionalIterator, typename _Distance, 
  typename _Pointer, typename _Compare>
  void
  __merge_adaptive(_BidirectionalIterator __first,
     _BidirectionalIterator __middle,
     _BidirectionalIterator __last,
     _Distance __len1, _Distance __len2,
     _Pointer __buffer, _Distance __buffer_size,
     _Compare __comp)
  {
    if (__len1 <= __len2 && __len1 <= __buffer_size)
{
 _Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer)std::move(__first, __middle, __buffer);
 std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
		     __first, __comp);
}
    else if (__len2 <= __buffer_size)
{
 _Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer)std::move(__middle, __last, __buffer);
 std::__move_merge_adaptive_backward(__first, __middle, __buffer,
			      __buffer_end, __last, __comp);
}
    else
{
 _BidirectionalIterator __first_cut = __first;
 _BidirectionalIterator __second_cut = __middle;
 _Distance __len11 = 0;
 _Distance __len22 = 0;
 if (__len1 > __len2)
   {
     __len11 = __len1 / 2;
     std::advance(__first_cut, __len11);
     __second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
		     __gnu_cxx::__ops::__iter_comp_val(__comp));
     __len22 = std::distance(__middle, __second_cut);
   }
 else
   {
     __len22 = __len2 / 2;
     std::advance(__second_cut, __len22);
     __first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
		     __gnu_cxx::__ops::__val_comp_iter(__comp));
     __len11 = std::distance(__first, __first_cut);
   }

 _BidirectionalIterator __new_middle
   = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
		     __len1 - __len11, __len22, __buffer,
		     __buffer_size);
 std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
		__len22, __buffer, __buffer_size, __comp);
 std::__merge_adaptive(__new_middle, __second_cut, __last,
		__len1 - __len11,
		__len2 - __len22, __buffer,
		__buffer_size, __comp);
}
  }

/// This is a helper function for the merge routines.
template<typename _BidirectionalIterator, typename _Distance,
  typename _Compare>
  void
  __merge_without_buffer(_BidirectionalIterator __first,
	   _BidirectionalIterator __middle,
	   _BidirectionalIterator __last,
	   _Distance __len1, _Distance __len2,
	   _Compare __comp)
  {
    if (__len1 == 0 || __len2 == 0)
return;

    if (__len1 + __len2 == 2)
{
 if (__comp(__middle, __first))
   std::iter_swap(__first, __middle);
 return;
}

    _BidirectionalIterator __first_cut = __first;
    _BidirectionalIterator __second_cut = __middle;
    _Distance __len11 = 0;
    _Distance __len22 = 0;
    if (__len1 > __len2)
{
 __len11 = __len1 / 2;
 std::advance(__first_cut, __len11);
 __second_cut
   = std::__lower_bound(__middle, __last, *__first_cut,
		 __gnu_cxx::__ops::__iter_comp_val(__comp));
 __len22 = std::distance(__middle, __second_cut);
}
    else
{
 __len22 = __len2 / 2;
 std::advance(__second_cut, __len22);
 __first_cut
   = std::__upper_bound(__first, __middle, *__second_cut,
		 __gnu_cxx::__ops::__val_comp_iter(__comp));
 __len11 = std::distance(__first, __first_cut);
}

    _BidirectionalIterator __new_middle
= std::rotate(__first_cut, __middle, __second_cut);
    std::__merge_without_buffer(__first, __first_cut, __new_middle,
		  __len11, __len22, __comp);
    std::__merge_without_buffer(__new_middle, __second_cut, __last,
		  __len1 - __len11, __len2 - __len22, __comp);
  }

template<typename _BidirectionalIterator, typename _Compare>
  void
  __inplace_merge(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last,
    _Compare __comp)
  {
    typedef typename iterator_traits<_BidirectionalIterator>::value_type
 _ValueType;
    typedef typename iterator_traits<_BidirectionalIterator>::difference_type
 _DistanceType;

    if (__first == __middle || __middle == __last)
return;

    const _DistanceType __len1 = std::distance(__first, __middle);
    const _DistanceType __len2 = std::distance(__middle, __last);

    typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
    _TmpBuf __buf(__first, __len1 + __len2);

    if (__buf.begin() == 0)
std::__merge_without_buffer
 (__first, __middle, __last, __len1, __len2, __comp);
    else
std::__merge_adaptive
 (__first, __middle, __last, __len1, __len2, __buf.begin(),
  _DistanceType(__buf.size()), __comp);
  }

/**
 *  @brief Merges two sorted ranges in place.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __middle  Another iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Merges two sorted and consecutive ranges, [__first,__middle) and
 *  [__middle,__last), and puts the result in [__first,__last).  The
 *  output will be sorted.  The sort is @e stable, that is, for
 *  equivalent elements in the two ranges, elements from the first
 *  range will always come before elements from the second.
 *
 *  If enough additional memory is available, this takes (__last-__first)-1
 *  comparisons.  Otherwise an NlogN algorithm is used, where N is
 *  distance(__first,__last).
*/
template<typename _BidirectionalIterator>
  inline void
  inplace_merge(_BidirectionalIterator __first,
  _BidirectionalIterator __middle,
  _BidirectionalIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
   _BidirectionalIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_sorted(__first, __middle);
    __glibcxx_requires_sorted(__middle, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    std::__inplace_merge(__first, __middle, __last,
	   __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Merges two sorted ranges in place.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __middle  Another iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A functor to use for comparisons.
 *  @return  Nothing.
 *
 *  Merges two sorted and consecutive ranges, [__first,__middle) and
 *  [middle,last), and puts the result in [__first,__last).  The output will
 *  be sorted.  The sort is @e stable, that is, for equivalent
 *  elements in the two ranges, elements from the first range will always
 *  come before elements from the second.
 *
 *  If enough additional memory is available, this takes (__last-__first)-1
 *  comparisons.  Otherwise an NlogN algorithm is used, where N is
 *  distance(__first,__last).
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _BidirectionalIterator, typename _Compare>
  inline void
  inplace_merge(_BidirectionalIterator __first,
  _BidirectionalIterator __middle,
  _BidirectionalIterator __last,
  _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
   _BidirectionalIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_BidirectionalIterator>::value_type,
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_sorted_pred(__first, __middle, __comp);
    __glibcxx_requires_sorted_pred(__middle, __last, __comp);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    std::__inplace_merge(__first, __middle, __last,
	   __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }


/// This is a helper function for the __merge_sort_loop routines.
template<typename _InputIterator, typename _OutputIterator,
  typename _Compare>
  _OutputIterator
  __move_merge(_InputIterator __first1, _InputIterator __last1,
 _InputIterator __first2, _InputIterator __last2,
 _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
{
 if (__comp(__first2, __first1))
   {
     *__result = _GLIBCXX_MOVE(*__first2)std::move(*__first2);
     ++__first2;
   }
 else
   {
     *__result = _GLIBCXX_MOVE(*__first1)std::move(*__first1);
     ++__first1;
   }
 ++__result;
}
    return _GLIBCXX_MOVE3(__first2, __last2,std::move(__first2, __last2, std::move(__first1, __last1, __result
))
	    _GLIBCXX_MOVE3(__first1, __last1,std::move(__first2, __last2, std::move(__first1, __last1, __result
))
			   __result))std::move(__first2, __last2, std::move(__first1, __last1, __result
));
  }

template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
  typename _Distance, typename _Compare>
  void
  __merge_sort_loop(_RandomAccessIterator1 __first,
      _RandomAccessIterator1 __last,
      _RandomAccessIterator2 __result, _Distance __step_size,
      _Compare __comp)
  {
    const _Distance __two_step = 2 * __step_size;

    while (__last - __first >= __two_step)
{
 __result = std::__move_merge(__first, __first + __step_size,
		       __first + __step_size,
		       __first + __two_step,
		       __result, __comp);
 __first += __two_step;
}
    __step_size = std::min(_Distance(__last - __first), __step_size);

    std::__move_merge(__first, __first + __step_size,
	__first + __step_size, __last, __result, __comp);
  }

template<typename _RandomAccessIterator, typename _Distance,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __chunk_insertion_sort(_RandomAccessIterator __first,
	   _RandomAccessIterator __last,
	   _Distance __chunk_size, _Compare __comp)
  {
    while (__last - __first >= __chunk_size)
{
 std::__insertion_sort(__first, __first + __chunk_size, __comp);
 __first += __chunk_size;
}
    std::__insertion_sort(__first, __last, __comp);
  }

enum { _S_chunk_size = 7 };

template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
  void
  __merge_sort_with_buffer(_RandomAccessIterator __first,
	     _RandomAccessIterator __last,
	     _Pointer __buffer, _Compare __comp)
  {
    typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;

    const _Distance __len = __last - __first;
    const _Pointer __buffer_last = __buffer + __len;

    _Distance __step_size = _S_chunk_size;
    std::__chunk_insertion_sort(__first, __last, __step_size, __comp);

    while (__step_size < __len)
{
 std::__merge_sort_loop(__first, __last, __buffer,
		 __step_size, __comp);
 __step_size *= 2;
 std::__merge_sort_loop(__buffer, __buffer_last, __first,
		 __step_size, __comp);
 __step_size *= 2;
}
  }

template<typename _RandomAccessIterator, typename _Pointer,
  typename _Distance, typename _Compare>
  void
  __stable_sort_adaptive(_RandomAccessIterator __first,
	   _RandomAccessIterator __last,
	   _Pointer __buffer, _Distance __buffer_size,
	   _Compare __comp)
  {
    const _Distance __len = (__last - __first + 1) / 2;
    const _RandomAccessIterator __middle = __first + __len;
    if (__len > __buffer_size)
{
 std::__stable_sort_adaptive(__first, __middle, __buffer,
		      __buffer_size, __comp);
 std::__stable_sort_adaptive(__middle, __last, __buffer,
		      __buffer_size, __comp);
}
    else
{
 std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
 std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
}
    std::__merge_adaptive(__first, __middle, __last,
	    _Distance(__middle - __first),
	    _Distance(__last - __middle),
	    __buffer, __buffer_size,
	    __comp);
  }

/// This is a helper function for the stable sorting routines.
template<typename _RandomAccessIterator, typename _Compare>
  void
  __inplace_stable_sort(_RandomAccessIterator __first,
	  _RandomAccessIterator __last, _Compare __comp)
  {
    if (__last - __first < 15)
{
 std::__insertion_sort(__first, __last, __comp);
 return;
}
    _RandomAccessIterator __middle = __first + (__last - __first) / 2;
    std::__inplace_stable_sort(__first, __middle, __comp);
    std::__inplace_stable_sort(__middle, __last, __comp);
    std::__merge_without_buffer(__first, __middle, __last,
		  __middle - __first,
		  __last - __middle,
		  __comp);
  }

// stable_sort

// Set algorithms: includes, set_union, set_intersection, set_difference,
// set_symmetric_difference.  All of these algorithms have the precondition
// that their input ranges are sorted and the postcondition that their output
// ranges are sorted.

template<typename _InputIterator1, typename _InputIterator2,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  bool
  __includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2,
      _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first2, __first1))
 return false;
else if (__comp(__first1, __first2))
 ++__first1;
else
 {
   ++__first1;
   ++__first2;
 }

    return __first2 == __last2;
  }

/**
 *  @brief Determines whether all elements of a sequence exists in a range.
 *  @param  __first1  Start of search range.
 *  @param  __last1   End of search range.
 *  @param  __first2  Start of sequence
 *  @param  __last2   End of sequence.
 *  @return  True if each element in [__first2,__last2) is contained in order
 *  within [__first1,__last1).  False otherwise.
 *  @ingroup set_algorithms
 *
 *  This operation expects both [__first1,__last1) and
 *  [__first2,__last2) to be sorted.  Searches for the presence of
 *  each element in [__first2,__last2) within [__first1,__last1).
 *  The iterators over each range only move forward, so this is a
 *  linear algorithm.  If an element in [__first2,__last2) is not
 *  found before the search iterator reaches @p __last2, false is
 *  returned.
*/
template<typename _InputIterator1, typename _InputIterator2>
  _GLIBCXX20_CONSTEXPR
  inline bool
  includes(_InputIterator1 __first1, _InputIterator1 __last1,
    _InputIterator2 __first2, _InputIterator2 __last2)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return std::__includes(__first1, __last1, __first2, __last2,
	     __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Determines whether all elements of a sequence exists in a range
 *  using comparison.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of search range.
 *  @param  __last1   End of search range.
 *  @param  __first2  Start of sequence
 *  @param  __last2   End of sequence.
 *  @param  __comp    Comparison function to use.
 *  @return True if each element in [__first2,__last2) is contained
 *  in order within [__first1,__last1) according to comp.  False
 *  otherwise.  @ingroup set_algorithms
 *
 *  This operation expects both [__first1,__last1) and
 *  [__first2,__last2) to be sorted.  Searches for the presence of
 *  each element in [__first2,__last2) within [__first1,__last1),
 *  using comp to decide.  The iterators over each range only move
 *  forward, so this is a linear algorithm.  If an element in
 *  [__first2,__last2) is not found before the search iterator
 *  reaches @p __last2, false is returned.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline bool
  includes(_InputIterator1 __first1, _InputIterator1 __last1,
    _InputIterator2 __first2, _InputIterator2 __last2,
    _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return std::__includes(__first1, __last1, __first2, __last2,
	     __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

// nth_element
// merge
// set_difference
// set_intersection
// set_union
// stable_sort
// set_symmetric_difference
// min_element
// max_element

template<typename _BidirectionalIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  bool
  __next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
  {
    if (__first == __last)
return false;
    _BidirectionalIterator __i = __first;
    ++__i;
    if (__i == __last)
return false;
    __i = __last;
    --__i;

    for(;;)
{
 _BidirectionalIterator __ii = __i;
 --__i;
 if (__comp(__i, __ii))
   {
     _BidirectionalIterator __j = __last;
     while (!__comp(__i, --__j))
{}
     std::iter_swap(__i, __j);
     std::__reverse(__ii, __last,
	     std::__iterator_category(__first));
     return true;
   }
 if (__i == __first)
   {
     std::__reverse(__first, __last,
	     std::__iterator_category(__first));
     return false;
   }
}
  }

/**
 *  @brief  Permute range into the next @e dictionary ordering.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  False if wrapped to first permutation, true otherwise.
 *
 *  Treats all permutations of the range as a set of @e dictionary sorted
 *  sequences.  Permutes the current sequence into the next one of this set.
 *  Returns true if there are more sequences to generate.  If the sequence
 *  is the largest of the set, the smallest is generated and false returned.
*/
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  inline bool
  next_permutation(_BidirectionalIterator __first,
     _BidirectionalIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return std::__next_permutation
(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Permute range into the next @e dictionary ordering using
 *          comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   A comparison functor.
 *  @return  False if wrapped to first permutation, true otherwise.
 *
 *  Treats all permutations of the range [__first,__last) as a set of
 *  @e dictionary sorted sequences ordered by @p __comp.  Permutes the current
 *  sequence into the next one of this set.  Returns true if there are more
 *  sequences to generate.  If the sequence is the largest of the set, the
 *  smallest is generated and false returned.
*/
template<typename _BidirectionalIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline bool
  next_permutation(_BidirectionalIterator __first,
     _BidirectionalIterator __last, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_BidirectionalIterator>::value_type,
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return std::__next_permutation
(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _BidirectionalIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  bool
  __prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
  {
    if (__first == __last)
return false;
    _BidirectionalIterator __i = __first;
    ++__i;
    if (__i == __last)
return false;
    __i = __last;
    --__i;

    for(;;)
{
 _BidirectionalIterator __ii = __i;
 --__i;
 if (__comp(__ii, __i))
   {
     _BidirectionalIterator __j = __last;
     while (!__comp(--__j, __i))
{}
     std::iter_swap(__i, __j);
     std::__reverse(__ii, __last,
	     std::__iterator_category(__first));
     return true;
   }
 if (__i == __first)
   {
     std::__reverse(__first, __last,
	     std::__iterator_category(__first));
     return false;
   }
}
  }

/**
 *  @brief  Permute range into the previous @e dictionary ordering.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  False if wrapped to last permutation, true otherwise.
 *
 *  Treats all permutations of the range as a set of @e dictionary sorted
 *  sequences.  Permutes the current sequence into the previous one of this
 *  set.  Returns true if there are more sequences to generate.  If the
 *  sequence is the smallest of the set, the largest is generated and false
 *  returned.
*/
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  inline bool
  prev_permutation(_BidirectionalIterator __first,
     _BidirectionalIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return std::__prev_permutation(__first, __last,
		     __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Permute range into the previous @e dictionary ordering using
 *          comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   A comparison functor.
 *  @return  False if wrapped to last permutation, true otherwise.
 *
 *  Treats all permutations of the range [__first,__last) as a set of
 *  @e dictionary sorted sequences ordered by @p __comp.  Permutes the current
 *  sequence into the previous one of this set.  Returns true if there are
 *  more sequences to generate.  If the sequence is the smallest of the set,
 *  the largest is generated and false returned.
*/
template<typename _BidirectionalIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline bool
  prev_permutation(_BidirectionalIterator __first,
     _BidirectionalIterator __last, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_BidirectionalIterator>::value_type,
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return std::__prev_permutation(__first, __last,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

// replace
// replace_if

template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __replace_copy_if(_InputIterator __first, _InputIterator __last,
      _OutputIterator __result,
      _Predicate __pred, const _Tp& __new_value)
  {
    for (; __first != __last; ++__first, (void)++__result)
if (__pred(__first))
 *__result = __new_value;
else
 *__result = *__first;
    return __result;
  }

/**
 *  @brief Copy a sequence, replacing each element of one value with another
 *         value.
 *  @param  __first      An input iterator.
 *  @param  __last       An input iterator.
 *  @param  __result     An output iterator.
 *  @param  __old_value  The value to be replaced.
 *  @param  __new_value  The replacement value.
 *  @return   The end of the output sequence, @p result+(last-first).
 *
 *  Copies each element in the input range @p [__first,__last) to the
 *  output range @p [__result,__result+(__last-__first)) replacing elements
 *  equal to @p __old_value with @p __new_value.
*/
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  replace_copy(_InputIterator __first, _InputIterator __last,
 _OutputIterator __result,
 const _Tp& __old_value, const _Tp& __new_value)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_InputIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__replace_copy_if(__first, __last, __result,
	__gnu_cxx::__ops::__iter_equals_val(__old_value),
			      __new_value);
  }

/**
 *  @brief Copy a sequence, replacing each value for which a predicate
 *         returns true with another value.
 *  @ingroup mutating_algorithms
 *  @param  __first      An input iterator.
 *  @param  __last       An input iterator.
 *  @param  __result     An output iterator.
 *  @param  __pred       A predicate.
 *  @param  __new_value  The replacement value.
 *  @return   The end of the output sequence, @p __result+(__last-__first).
 *
 *  Copies each element in the range @p [__first,__last) to the range
 *  @p [__result,__result+(__last-__first)) replacing elements for which
 *  @p __pred returns true with @p __new_value.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  replace_copy_if(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result,
    _Predicate __pred, const _Tp& __new_value)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__replace_copy_if(__first, __last, __result,
		__gnu_cxx::__ops::__pred_iter(__pred),
			      __new_value);
  }

3212#if __cplusplus201402L >= 201103L
/**
 *  @brief  Determines whether the elements of a sequence are sorted.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @return  True if the elements are sorted, false otherwise.
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_sorted(_ForwardIterator __first, _ForwardIterator __last)
  { return std::is_sorted_until(__first, __last) == __last; }

/**
 *  @brief  Determines whether the elements of a sequence are sorted
 *          according to a comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  True if the elements are sorted, false otherwise.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_sorted(_ForwardIterator __first, _ForwardIterator __last,
     _Compare __comp)
  { return std::is_sorted_until(__first, __last, __comp) == __last; }

template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
      _Compare __comp)
  {
    if (__first == __last)
return __last;

    _ForwardIterator __next = __first;
    for (++__next; __next != __last; __first = __next, (void)++__next)
if (__comp(__next, __first))
 return __next;
    return __next;
  }

/**
 *  @brief  Determines the end of a sorted sequence.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @return  An iterator pointing to the last iterator i in [__first, __last)
 *           for which the range [__first, i) is sorted.
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return std::__is_sorted_until(__first, __last,
		    __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Determines the end of a sorted sequence using comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  An iterator pointing to the last iterator i in [__first, __last)
 *           for which the range [__first, i) is sorted.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
    _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return std::__is_sorted_until(__first, __last,
		    __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

/**
 *  @brief  Determines min and max at once as an ordered pair.
 *  @ingroup sorting_algorithms
 *  @param  __a  A thing of arbitrary type.
 *  @param  __b  Another thing of arbitrary type.
 *  @return A pair(__b, __a) if __b is smaller than __a, pair(__a,
 *  __b) otherwise.
*/
template<typename _Tp>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<const _Tp&, const _Tp&>
  minmax(const _Tp& __a, const _Tp& __b)
  {
    // concept requirements
    __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)

    return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
       : pair<const _Tp&, const _Tp&>(__a, __b);
  }

/**
 *  @brief  Determines min and max at once as an ordered pair.
 *  @ingroup sorting_algorithms
 *  @param  __a  A thing of arbitrary type.
 *  @param  __b  Another thing of arbitrary type.
 *  @param  __comp  A @link comparison_functors comparison functor @endlink.
 *  @return A pair(__b, __a) if __b is smaller than __a, pair(__a,
 *  __b) otherwise.
*/
template<typename _Tp, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<const _Tp&, const _Tp&>
  minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
  {
    return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
	      : pair<const _Tp&, const _Tp&>(__a, __b);
  }

template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  pair<_ForwardIterator, _ForwardIterator>
  __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
     _Compare __comp)
  {
    _ForwardIterator __next = __first;
    if (__first == __last
 || ++__next == __last)
return std::make_pair(__first, __first);

    _ForwardIterator __min{}, __max{};
    if (__comp(__next, __first))
{
 __min = __next;
 __max = __first;
}
    else
{
 __min = __first;
 __max = __next;
}

    __first = __next;
    ++__first;

    while (__first != __last)
{
 __next = __first;
 if (++__next == __last)
   {
     if (__comp(__first, __min))
__min = __first;
     else if (!__comp(__first, __max))
__max = __first;
     break;
   }

 if (__comp(__next, __first))
   {
     if (__comp(__next, __min))
__min = __next;
     if (!__comp(__first, __max))
__max = __first;
   }
 else
   {
     if (__comp(__first, __min))
__min = __first;
     if (!__comp(__next, __max))
__max = __next;
   }

 __first = __next;
 ++__first;
}

    return std::make_pair(__min, __max);
  }

/**
 *  @brief  Return a pair of iterators pointing to the minimum and maximum
 *          elements in a range.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  make_pair(m, M), where m is the first iterator i in 
 *           [__first, __last) such that no other element in the range is
 *           smaller, and where M is the last iterator i in [__first, __last)
 *           such that no other element in the range is larger.
*/
template<typename _ForwardIterator>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<_ForwardIterator, _ForwardIterator>
  minmax_element(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return std::__minmax_element(__first, __last,
		   __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return a pair of iterators pointing to the minimum and maximum
 *          elements in a range.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   Comparison functor.
 *  @return  make_pair(m, M), where m is the first iterator i in 
 *           [__first, __last) such that no other element in the range is
 *           smaller, and where M is the last iterator i in [__first, __last)
 *           such that no other element in the range is larger.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<_ForwardIterator, _ForwardIterator>
  minmax_element(_ForwardIterator __first, _ForwardIterator __last,
   _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return std::__minmax_element(__first, __last,
		   __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

// N2722 + DR 915.
template<typename _Tp>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Tp
  min(initializer_list<_Tp> __l)
  { return *std::min_element(__l.begin(), __l.end()); }

template<typename _Tp, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Tp
  min(initializer_list<_Tp> __l, _Compare __comp)
  { return *std::min_element(__l.begin(), __l.end(), __comp); }

template<typename _Tp>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Tp
  max(initializer_list<_Tp> __l)
  { return *std::max_element(__l.begin(), __l.end()); }

template<typename _Tp, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Tp
  max(initializer_list<_Tp> __l, _Compare __comp)
  { return *std::max_element(__l.begin(), __l.end(), __comp); }

template<typename _Tp>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<_Tp, _Tp>
  minmax(initializer_list<_Tp> __l)
  {
    pair<const _Tp*, const _Tp*> __p =
std::minmax_element(__l.begin(), __l.end());
    return std::make_pair(*__p.first, *__p.second);
  }

template<typename _Tp, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<_Tp, _Tp>
  minmax(initializer_list<_Tp> __l, _Compare __comp)
  {
    pair<const _Tp*, const _Tp*> __p =
std::minmax_element(__l.begin(), __l.end(), __comp);
    return std::make_pair(*__p.first, *__p.second);
  }

/**
 *  @brief  Checks whether a permutation of the second sequence is equal
 *          to the first sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __pred    A binary predicate.
 *  @return true if there exists a permutation of the elements in
 *          the range [__first2, __first2 + (__last1 - __first1)),
 *          beginning with ForwardIterator2 begin, such that
 *          equal(__first1, __last1, __begin, __pred) returns true;
 *          otherwise, returns false.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
   _ForwardIterator2 __first2, _BinaryPredicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);

    return std::__is_permutation(__first1, __last1, __first2,
		   __gnu_cxx::__ops::__iter_comp_iter(__pred));
  }

3542#if __cplusplus201402L > 201103L
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  bool
  __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
     _BinaryPredicate __pred)
  {
    using _Cat1
= typename iterator_traits<_ForwardIterator1>::iterator_category;
    using _Cat2
= typename iterator_traits<_ForwardIterator2>::iterator_category;
    using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
    using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
    constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
    if (__ra_iters)
{
 auto __d1 = std::distance(__first1, __last1);
 auto __d2 = std::distance(__first2, __last2);
 if (__d1 != __d2)
   return false;
}

    // Efficiently compare identical prefixes:  O(N) if sequences
    // have the same elements in the same order.
    for (; __first1 != __last1 && __first2 != __last2;
 ++__first1, (void)++__first2)
if (!__pred(__first1, __first2))
 break;

    if (__ra_iters)
{
 if (__first1 == __last1)
   return true;
}
    else
{
 auto __d1 = std::distance(__first1, __last1);
 auto __d2 = std::distance(__first2, __last2);
 if (__d1 == 0 && __d2 == 0)
   return true;
 if (__d1 != __d2)
   return false;
}

    for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
{
 if (__scan != std::__find_if(__first1, __scan,
	__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
   continue; // We've seen this one before.

 auto __matches = std::__count_if(__first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
 if (0 == __matches
     || std::__count_if(__scan, __last1,
	__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
     != __matches)
   return false;
}
    return true;
  }

/**
 *  @brief  Checks whether a permutaion of the second sequence is equal
 *          to the first sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of first range.
 *  @return true if there exists a permutation of the elements in the range
 *          [__first2, __last2), beginning with ForwardIterator2 begin,
 *          such that equal(__first1, __last1, begin) returns true;
 *          otherwise, returns false.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
   _ForwardIterator2 __first2, _ForwardIterator2 __last2)
  {
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return
std::__is_permutation(__first1, __last1, __first2, __last2,
	      __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief  Checks whether a permutation of the second sequence is equal
 *          to the first sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of first range.
 *  @param  __pred    A binary predicate.
 *  @return true if there exists a permutation of the elements in the range
 *          [__first2, __last2), beginning with ForwardIterator2 begin,
 *          such that equal(__first1, __last1, __begin, __pred) returns true;
 *          otherwise, returns false.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
   _ForwardIterator2 __first2, _ForwardIterator2 __last2,
   _BinaryPredicate __pred)
  {
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__is_permutation(__first1, __last1, __first2, __last2,
		   __gnu_cxx::__ops::__iter_comp_iter(__pred));
  }

3661#if __cplusplus201402L > 201402L

3663#define __cpp_lib_clamp 201603

/**
 *  @brief  Returns the value clamped between lo and hi.
 *  @ingroup sorting_algorithms
 *  @param  __val  A value of arbitrary type.
 *  @param  __lo   A lower limit of arbitrary type.
 *  @param  __hi   An upper limit of arbitrary type.
 *  @return max(__val, __lo) if __val < __hi or min(__val, __hi) otherwise.
 */
template<typename _Tp>
  constexpr const _Tp&
  clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi)
  {
    __glibcxx_assert(!(__hi < __lo));
    return (__val < __lo) ? __lo : (__hi < __val) ? __hi : __val;
  }

/**
 *  @brief  Returns the value clamped between lo and hi.
 *  @ingroup sorting_algorithms
 *  @param  __val   A value of arbitrary type.
 *  @param  __lo    A lower limit of arbitrary type.
 *  @param  __hi    An upper limit of arbitrary type.
 *  @param  __comp  A comparison functor.
 *  @return max(__val, __lo, __comp) if __comp(__val, __hi)
 *	      or min(__val, __hi, __comp) otherwise.
 */
template<typename _Tp, typename _Compare>
  constexpr const _Tp&
  clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
  {
    __glibcxx_assert(!__comp(__hi, __lo));
    return __comp(__val, __lo) ? __lo : __comp(__hi, __val) ? __hi : __val;
  }
3698#endif // C++17
3699#endif // C++14

3701#ifdef _GLIBCXX_USE_C99_STDINT_TR11
/**
 *  @brief Generate two uniformly distributed integers using a
 *         single distribution invocation.
 *  @param  __b0    The upper bound for the first integer.
 *  @param  __b1    The upper bound for the second integer.
 *  @param  __g     A UniformRandomBitGenerator.
 *  @return  A pair (i, j) with i and j uniformly distributed
 *           over [0, __b0) and [0, __b1), respectively.
 *
 *  Requires: __b0 * __b1 <= __g.max() - __g.min().
 *
 *  Using uniform_int_distribution with a range that is very
 *  small relative to the range of the generator ends up wasting
 *  potentially expensively generated randomness, since
 *  uniform_int_distribution does not store leftover randomness
 *  between invocations.
 *
 *  If we know we want two integers in ranges that are sufficiently
 *  small, we can compose the ranges, use a single distribution
 *  invocation, and significantly reduce the waste.
*/
template<typename _IntType, typename _UniformRandomBitGenerator>
  pair<_IntType, _IntType>
  __gen_two_uniform_ints(_IntType __b0, _IntType __b1,
	   _UniformRandomBitGenerator&& __g)
  {
    _IntType __x
= uniform_int_distribution<_IntType>{0, (__b0 * __b1) - 1}(__g);
    return std::make_pair(__x / __b1, __x % __b1);
  }

/**
 *  @brief Shuffle the elements of a sequence using a uniform random
 *         number generator.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __g       A UniformRandomNumberGenerator (26.5.1.3).
 *  @return  Nothing.
 *
 *  Reorders the elements in the range @p [__first,__last) using @p __g to
 *  provide random numbers.
*/
template<typename _RandomAccessIterator,
  typename _UniformRandomNumberGenerator>
  void
  shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
   _UniformRandomNumberGenerator&& __g)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first == __last)
return;

    typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;

    typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
    typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
    typedef typename __distr_type::param_type __p_type;

    typedef typename remove_reference<_UniformRandomNumberGenerator>::type
_Gen;
    typedef typename common_type<typename _Gen::result_type, __ud_type>::type
__uc_type;

    const __uc_type __urngrange = __g.max() - __g.min();
    const __uc_type __urange = __uc_type(__last - __first);

    if (__urngrange / __urange >= __urange)
      // I.e. (__urngrange >= __urange * __urange) but without wrap issues.
    {
_RandomAccessIterator __i = __first + 1;

// Since we know the range isn't empty, an even number of elements
// means an uneven number of elements /to swap/, in which case we
// do the first one up front:

if ((__urange % 2) == 0)
{
 __distr_type __d{0, 1};
 std::iter_swap(__i++, __first + __d(__g));
}

// Now we know that __last - __i is even, so we do the rest in pairs,
// using a single distribution invocation to produce swap positions
// for two successive elements at a time:

while (__i != __last)
{
 const __uc_type __swap_range = __uc_type(__i - __first) + 1;

 const pair<__uc_type, __uc_type> __pospos =
   __gen_two_uniform_ints(__swap_range, __swap_range + 1, __g);

 std::iter_swap(__i++, __first + __pospos.first);
 std::iter_swap(__i++, __first + __pospos.second);
}

return;
    }

    __distr_type __d;

    for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
  }
3812#endif

3814#endif // C++11

3816_GLIBCXX_BEGIN_NAMESPACE_ALGO

/**
 *  @brief Apply a function to every element of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __f      A unary function object.
 *  @return   @p __f
 *
 *  Applies the function object @p __f to each element in the range
 *  @p [first,last).  @p __f must not modify the order of the sequence.
 *  If @p __f has a return value it is ignored.
*/
template<typename _InputIterator, typename _Function>
  _GLIBCXX20_CONSTEXPR
  _Function
  for_each(_InputIterator __first, _InputIterator __last, _Function __f)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_requires_valid_range(__first, __last);
    for (; __first != __last; ++__first)
__f(*__first);
    return __f; // N.B. [alg.foreach] says std::move(f) but it's redundant.
  }

3843#if __cplusplus201402L >= 201703L
/**
 *  @brief Apply a function to every element of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __n      A value convertible to an integer.
 *  @param  __f      A unary function object.
 *  @return   `__first+__n`
 *
 *  Applies the function object `__f` to each element in the range
 *  `[first, first+n)`.  `__f` must not modify the order of the sequence.
 *  If `__f` has a return value it is ignored.
*/
template<typename _InputIterator, typename _Size, typename _Function>
  _GLIBCXX20_CONSTEXPR
  _InputIterator
  for_each_n(_InputIterator __first, _Size __n, _Function __f)
  {
    auto __n2 = std::__size_to_integer(__n);
    using _Cat = typename iterator_traits<_InputIterator>::iterator_category;
    if constexpr (is_base_of_v<random_access_iterator_tag, _Cat>)
{
 if (__n2 <= 0)
   return __first;
 auto __last = __first + __n2;
 std::for_each(__first, __last, std::move(__f));
 return __last;
}
    else
{
 while (__n2-->0)
   {
     __f(*__first);
     ++__first;
   }
 return __first;
}
  }
3881#endif // C++17

/**
 *  @brief Find the first occurrence of a value in a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __val    The value to find.
 *  @return   The first iterator @c i in the range @p [__first,__last)
 *  such that @c *i == @p __val, or @p __last if no such iterator exists.
*/
template<typename _InputIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _InputIterator
  find(_InputIterator __first, _InputIterator __last,
const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
typename iterator_traits<_InputIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);
    return std::__find_if(__first, __last,
	    __gnu_cxx::__ops::__iter_equals_val(__val));
  }

/**
 *  @brief Find the first element in a sequence for which a
 *         predicate is true.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __pred   A predicate.
 *  @return   The first iterator @c i in the range @p [__first,__last)
 *  such that @p __pred(*i) is true, or @p __last if no such iterator exists.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _InputIterator
  find_if(_InputIterator __first, _InputIterator __last,
   _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__find_if(__first, __last,
	    __gnu_cxx::__ops::__pred_iter(__pred));
  }

/**
 *  @brief  Find element from a set in a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of range to search.
 *  @param  __last1   End of range to search.
 *  @param  __first2  Start of match candidates.
 *  @param  __last2   End of match candidates.
 *  @return   The first iterator @c i in the range
 *  @p [__first1,__last1) such that @c *i == @p *(i2) such that i2 is an
 *  iterator in [__first2,__last2), or @p __last1 if no such iterator exists.
 *
 *  Searches the range @p [__first1,__last1) for an element that is
 *  equal to some element in the range [__first2,__last2).  If
 *  found, returns an iterator in the range [__first1,__last1),
 *  otherwise returns @p __last1.
*/
template<typename _InputIterator, typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  _InputIterator
  find_first_of(_InputIterator __first1, _InputIterator __last1,
  _ForwardIterator __first2, _ForwardIterator __last2)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_InputIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    for (; __first1 != __last1; ++__first1)
for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
 if (*__first1 == *__iter)
   return __first1;
    return __last1;
  }

/**
 *  @brief  Find element from a set in a sequence using a predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of range to search.
 *  @param  __last1   End of range to search.
 *  @param  __first2  Start of match candidates.
 *  @param  __last2   End of match candidates.
 *  @param  __comp    Predicate to use.
 *  @return   The first iterator @c i in the range
 *  @p [__first1,__last1) such that @c comp(*i, @p *(i2)) is true
 *  and i2 is an iterator in [__first2,__last2), or @p __last1 if no
 *  such iterator exists.
 *

 *  Searches the range @p [__first1,__last1) for an element that is
 *  equal to some element in the range [__first2,__last2).  If
 *  found, returns an iterator in the range [__first1,__last1),
 *  otherwise returns @p __last1.
*/
template<typename _InputIterator, typename _ForwardIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _InputIterator
  find_first_of(_InputIterator __first1, _InputIterator __last1,
  _ForwardIterator __first2, _ForwardIterator __last2,
  _BinaryPredicate __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_InputIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    for (; __first1 != __last1; ++__first1)
for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
 if (__comp(*__first1, *__iter))
   return __first1;
    return __last1;
  }

/**
 *  @brief Find two adjacent values in a sequence that are equal.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @return   The first iterator @c i such that @c i and @c i+1 are both
 *  valid iterators in @p [__first,__last) and such that @c *i == @c *(i+1),
 *  or @p __last if no such iterator exists.
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_EqualityComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__adjacent_find(__first, __last,
		  __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief Find two adjacent values in a sequence using a predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first         A forward iterator.
 *  @param  __last          A forward iterator.
 *  @param  __binary_pred   A binary predicate.
 *  @return   The first iterator @c i such that @c i and @c i+1 are both
 *  valid iterators in @p [__first,__last) and such that
 *  @p __binary_pred(*i,*(i+1)) is true, or @p __last if no such iterator
 *  exists.
*/
template<typename _ForwardIterator, typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
  _BinaryPredicate __binary_pred)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__adjacent_find(__first, __last,
	__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
  }

/**
 *  @brief Count the number of copies of a value in a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __value  The value to be counted.
 *  @return   The number of iterators @c i in the range @p [__first,__last)
 *  for which @c *i == @p __value
*/
template<typename _InputIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline typename iterator_traits<_InputIterator>::difference_type
  count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_InputIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__count_if(__first, __last,
	     __gnu_cxx::__ops::__iter_equals_val(__value));
  }

/**
 *  @brief Count the elements of a sequence for which a predicate is true.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __pred   A predicate.
 *  @return   The number of iterators @c i in the range @p [__first,__last)
 *  for which @p __pred(*i) is true.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline typename iterator_traits<_InputIterator>::difference_type
  count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__count_if(__first, __last,
	     __gnu_cxx::__ops::__pred_iter(__pred));
  }

/**
 *  @brief Search a sequence for a matching sub-sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  A forward iterator.
 *  @param  __last1   A forward iterator.
 *  @param  __first2  A forward iterator.
 *  @param  __last2   A forward iterator.
 *  @return The first iterator @c i in the range @p
 *  [__first1,__last1-(__last2-__first2)) such that @c *(i+N) == @p
 *  *(__first2+N) for each @c N in the range @p
 *  [0,__last2-__first2), or @p __last1 if no such iterator exists.
 *
 *  Searches the range @p [__first1,__last1) for a sub-sequence that
 *  compares equal value-by-value with the sequence given by @p
 *  [__first2,__last2) and returns an iterator to the first element
 *  of the sub-sequence, or @p __last1 if the sub-sequence is not
 *  found.
 *
 *  Because the sub-sequence must lie completely within the range @p
 *  [__first1,__last1) it must start at a position less than @p
 *  __last1-(__last2-__first2) where @p __last2-__first2 is the
 *  length of the sub-sequence.
 *
 *  This means that the returned iterator @c i will be in the range
 *  @p [__first1,__last1-(__last2-__first2))
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator1
  search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
  _ForwardIterator2 __first2, _ForwardIterator2 __last2)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__search(__first1, __last1, __first2, __last2,
	   __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief Search a sequence for a matching sub-sequence using a predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1     A forward iterator.
 *  @param  __last1      A forward iterator.
 *  @param  __first2     A forward iterator.
 *  @param  __last2      A forward iterator.
 *  @param  __predicate  A binary predicate.
 *  @return   The first iterator @c i in the range
 *  @p [__first1,__last1-(__last2-__first2)) such that
 *  @p __predicate(*(i+N),*(__first2+N)) is true for each @c N in the range
 *  @p [0,__last2-__first2), or @p __last1 if no such iterator exists.
 *
 *  Searches the range @p [__first1,__last1) for a sub-sequence that
 *  compares equal value-by-value with the sequence given by @p
 *  [__first2,__last2), using @p __predicate to determine equality,
 *  and returns an iterator to the first element of the
 *  sub-sequence, or @p __last1 if no such iterator exists.
 *
 *  @see search(_ForwardIter1, _ForwardIter1, _ForwardIter2, _ForwardIter2)
*/
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator1
  search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
  _ForwardIterator2 __first2, _ForwardIterator2 __last2,
  _BinaryPredicate  __predicate)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__search(__first1, __last1, __first2, __last2,
	   __gnu_cxx::__ops::__iter_comp_iter(__predicate));
  }

/**
 *  @brief Search a sequence for a number of consecutive values.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @param  __count  The number of consecutive values.
 *  @param  __val    The value to find.
 *  @return The first iterator @c i in the range @p
 *  [__first,__last-__count) such that @c *(i+N) == @p __val for
 *  each @c N in the range @p [0,__count), or @p __last if no such
 *  iterator exists.
 *
 *  Searches the range @p [__first,__last) for @p count consecutive elements
 *  equal to @p __val.
*/
template<typename _ForwardIterator, typename _Integer, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  search_n(_ForwardIterator __first, _ForwardIterator __last,
    _Integer __count, const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__search_n(__first, __last, __count,
	     __gnu_cxx::__ops::__iter_equals_val(__val));
  }


/**
 *  @brief Search a sequence for a number of consecutive values using a
 *         predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first        A forward iterator.
 *  @param  __last         A forward iterator.
 *  @param  __count        The number of consecutive values.
 *  @param  __val          The value to find.
 *  @param  __binary_pred  A binary predicate.
 *  @return The first iterator @c i in the range @p
 *  [__first,__last-__count) such that @p
 *  __binary_pred(*(i+N),__val) is true for each @c N in the range
 *  @p [0,__count), or @p __last if no such iterator exists.
 *
 *  Searches the range @p [__first,__last) for @p __count
 *  consecutive elements for which the predicate returns true.
*/
template<typename _ForwardIterator, typename _Integer, typename _Tp,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  search_n(_ForwardIterator __first, _ForwardIterator __last,
    _Integer __count, const _Tp& __val,
    _BinaryPredicate __binary_pred)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__search_n(__first, __last, __count,
__gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
  }

4268#if __cplusplus201402L > 201402L
/** @brief Search a sequence using a Searcher object.
 *
 *  @param  __first        A forward iterator.
 *  @param  __last         A forward iterator.
 *  @param  __searcher     A callable object.
 *  @return @p __searcher(__first,__last).first
*/
template<typename _ForwardIterator, typename _Searcher>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  search(_ForwardIterator __first, _ForwardIterator __last,
  const _Searcher& __searcher)
  { return __searcher(__first, __last).first; }
4282#endif

/**
 *  @brief Perform an operation on a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first     An input iterator.
 *  @param  __last      An input iterator.
 *  @param  __result    An output iterator.
 *  @param  __unary_op  A unary operator.
 *  @return   An output iterator equal to @p __result+(__last-__first).
 *
 *  Applies the operator to each element in the input range and assigns
 *  the results to successive elements of the output sequence.
 *  Evaluates @p *(__result+N)=unary_op(*(__first+N)) for each @c N in the
 *  range @p [0,__last-__first).
 *
 *  @p unary_op must not alter its argument.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _UnaryOperation>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  transform(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _UnaryOperation __unary_op)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   // "the type returned by a _UnaryOperation"
   __typeof__(__unary_op(*__first))>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first, (void)++__result)
*__result = __unary_op(*__first);
    return __result;
  }

/**
 *  @brief Perform an operation on corresponding elements of two sequences.
 *  @ingroup mutating_algorithms
 *  @param  __first1     An input iterator.
 *  @param  __last1      An input iterator.
 *  @param  __first2     An input iterator.
 *  @param  __result     An output iterator.
 *  @param  __binary_op  A binary operator.
 *  @return   An output iterator equal to @p result+(last-first).
 *
 *  Applies the operator to the corresponding elements in the two
 *  input ranges and assigns the results to successive elements of the
 *  output sequence.
 *  Evaluates @p
 *  *(__result+N)=__binary_op(*(__first1+N),*(__first2+N)) for each
 *  @c N in the range @p [0,__last1-__first1).
 *
 *  @p binary_op must not alter either of its arguments.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _BinaryOperation>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  transform(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _OutputIterator __result,
     _BinaryOperation __binary_op)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   // "the type returned by a _BinaryOperation"
   __typeof__(__binary_op(*__first1,*__first2))>)
    __glibcxx_requires_valid_range(__first1, __last1);

    for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
*__result = __binary_op(*__first1, *__first2);
    return __result;
  }

/**
 *  @brief Replace each occurrence of one value in a sequence with another
 *         value.
 *  @ingroup mutating_algorithms
 *  @param  __first      A forward iterator.
 *  @param  __last       A forward iterator.
 *  @param  __old_value  The value to be replaced.
 *  @param  __new_value  The replacement value.
 *  @return   replace() returns no value.
 *
 *  For each iterator @c i in the range @p [__first,__last) if @c *i ==
 *  @p __old_value then the assignment @c *i = @p __new_value is performed.
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  void
  replace(_ForwardIterator __first, _ForwardIterator __last,
   const _Tp& __old_value, const _Tp& __new_value)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_function_requires(_ConvertibleConcept<_Tp,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first)
if (*__first == __old_value)
 *__first = __new_value;
  }

/**
 *  @brief Replace each value in a sequence for which a predicate returns
 *         true with another value.
 *  @ingroup mutating_algorithms
 *  @param  __first      A forward iterator.
 *  @param  __last       A forward iterator.
 *  @param  __pred       A predicate.
 *  @param  __new_value  The replacement value.
 *  @return   replace_if() returns no value.
 *
 *  For each iterator @c i in the range @p [__first,__last) if @p __pred(*i)
 *  is true then the assignment @c *i = @p __new_value is performed.
*/
template<typename _ForwardIterator, typename _Predicate, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  void
  replace_if(_ForwardIterator __first, _ForwardIterator __last,
      _Predicate __pred, const _Tp& __new_value)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_ConvertibleConcept<_Tp,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first)
if (__pred(*__first))
 *__first = __new_value;
  }

/**
 *  @brief Assign the result of a function object to each value in a
 *         sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @param  __gen    A function object taking no arguments and returning
 *                 std::iterator_traits<_ForwardIterator>::value_type
 *  @return   generate() returns no value.
 *
 *  Performs the assignment @c *i = @p __gen() for each @c i in the range
 *  @p [__first,__last).
*/
template<typename _ForwardIterator, typename _Generator>
  _GLIBCXX20_CONSTEXPR
  void
  generate(_ForwardIterator __first, _ForwardIterator __last,
    _Generator __gen)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_GeneratorConcept<_Generator,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first)
*__first = __gen();
  }

/**
 *  @brief Assign the result of a function object to each value in a
 *         sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __n      The length of the sequence.
 *  @param  __gen    A function object taking no arguments and returning
 *                 std::iterator_traits<_ForwardIterator>::value_type
 *  @return   The end of the sequence, @p __first+__n
 *
 *  Performs the assignment @c *i = @p __gen() for each @c i in the range
 *  @p [__first,__first+__n).
 *
 * If @p __n is negative, the function does nothing and returns @p __first.
*/
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 865. More algorithms that throw away information
// DR 426. search_n(), fill_n(), and generate_n() with negative n
template<typename _OutputIterator, typename _Size, typename _Generator>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
  {
    // concept requirements
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   // "the type returned by a _Generator"
   __typeof__(__gen())>)

    typedef __decltype(std::__size_to_integer(__n)) _IntSize;
    for (_IntSize __niter = std::__size_to_integer(__n);
  __niter > 0; --__niter, (void) ++__first)
*__first = __gen();
    return __first;
  }

/**
 *  @brief Copy a sequence, removing consecutive duplicate values.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __result  An output iterator.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) to the range
 *  beginning at @p __result, except that only the first element is copied
 *  from groups of consecutive elements that compare equal.
 *  unique_copy() is stable, so the relative order of elements that are
 *  copied is unchanged.
 *
 *  _GLIBCXX_RESOLVE_LIB_DEFECTS
 *  DR 241. Does unique_copy() require CopyConstructible and Assignable?
 *  
 *  _GLIBCXX_RESOLVE_LIB_DEFECTS
 *  DR 538. 241 again: Does unique_copy() require CopyConstructible and 
 *  Assignable?
*/
template<typename _InputIterator, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_EqualityComparableConcept<
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first == __last)
return __result;
    return std::__unique_copy(__first, __last, __result,
		__gnu_cxx::__ops::__iter_equal_to_iter(),
		std::__iterator_category(__first),
		std::__iterator_category(__result));
  }

/**
 *  @brief Copy a sequence, removing consecutive values using a predicate.
 *  @ingroup mutating_algorithms
 *  @param  __first        An input iterator.
 *  @param  __last         An input iterator.
 *  @param  __result       An output iterator.
 *  @param  __binary_pred  A binary predicate.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) to the range
 *  beginning at @p __result, except that only the first element is copied
 *  from groups of consecutive elements for which @p __binary_pred returns
 *  true.
 *  unique_copy() is stable, so the relative order of elements that are
 *  copied is unchanged.
 *
 *  _GLIBCXX_RESOLVE_LIB_DEFECTS
 *  DR 241. Does unique_copy() require CopyConstructible and Assignable?
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
_BinaryPredicate __binary_pred)
  {
    // concept requirements -- predicates checked later
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first == __last)
return __result;
    return std::__unique_copy(__first, __last, __result,
	__gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
		std::__iterator_category(__first),
		std::__iterator_category(__result));
  }

4573#if _GLIBCXX_HOSTED1
/**
 *  @brief Randomly shuffle the elements of a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @return  Nothing.
 *
 *  Reorder the elements in the range @p [__first,__last) using a random
 *  distribution, so that every possible ordering of the sequence is
 *  equally likely.
*/
template<typename _RandomAccessIterator>
  inline void
  random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first != __last)
for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   // XXX rand() % N is not uniformly distributed
   _RandomAccessIterator __j = __first
			+ std::rand() % ((__i - __first) + 1);
   if (__i != __j)
     std::iter_swap(__i, __j);
 }
  }
4604#endif

/**
 *  @brief Shuffle the elements of a sequence using a random number
 *         generator.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __rand    The RNG functor or function.
 *  @return  Nothing.
 *
 *  Reorders the elements in the range @p [__first,__last) using @p __rand to
 *  provide a random distribution. Calling @p __rand(N) for a positive
 *  integer @p N should return a randomly chosen integer from the
 *  range [0,N).
*/
template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
  void
  random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
4623#if __cplusplus201402L >= 201103L
   _RandomNumberGenerator&& __rand)
4625#else
   _RandomNumberGenerator& __rand)
4627#endif
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first == __last)
return;
    for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
{
 _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
 if (__i != __j)
   std::iter_swap(__i, __j);
}
  }


/**
 *  @brief Move elements for which a predicate is true to the beginning
 *         of a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __pred    A predicate functor.
 *  @return  An iterator @p middle such that @p __pred(i) is true for each
 *  iterator @p i in the range @p [__first,middle) and false for each @p i
 *  in the range @p [middle,__last).
 *
 *  @p __pred must not modify its operand. @p partition() does not preserve
 *  the relative ordering of elements in each group, use
 *  @p stable_partition() if this is needed.
*/
template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  partition(_ForwardIterator __first, _ForwardIterator __last,
     _Predicate   __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__partition(__first, __last, __pred,
	      std::__iterator_category(__first));
  }


/**
 *  @brief Sort the smallest elements of a sequence.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __middle  Another iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Sorts the smallest @p (__middle-__first) elements in the range
 *  @p [first,last) and moves them to the range @p [__first,__middle). The
 *  order of the remaining elements in the range @p [__middle,__last) is
 *  undefined.
 *  After the sort if @e i and @e j are iterators in the range
 *  @p [__first,__middle) such that i precedes j and @e k is an iterator in
 *  the range @p [__middle,__last) then *j<*i and *k<*i are both false.
*/
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  inline void
  partial_sort(_RandomAccessIterator __first,
 _RandomAccessIterator __middle,
 _RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __middle);
    __glibcxx_requires_valid_range(__middle, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    std::__partial_sort(__first, __middle, __last,
	  __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Sort the smallest elements of a sequence using a predicate
 *         for comparison.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __middle  Another iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  Nothing.
 *
 *  Sorts the smallest @p (__middle-__first) elements in the range
 *  @p [__first,__last) and moves them to the range @p [__first,__middle). The
 *  order of the remaining elements in the range @p [__middle,__last) is
 *  undefined.
 *  After the sort if @e i and @e j are iterators in the range
 *  @p [__first,__middle) such that i precedes j and @e k is an iterator in
 *  the range @p [__middle,__last) then @p *__comp(j,*i) and @p __comp(*k,*i)
 *  are both false.
*/
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  partial_sort(_RandomAccessIterator __first,
 _RandomAccessIterator __middle,
 _RandomAccessIterator __last,
 _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_RandomAccessIterator>::value_type,
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __middle);
    __glibcxx_requires_valid_range(__middle, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    std::__partial_sort(__first, __middle, __last,
	  __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

/**
 *  @brief Sort a sequence just enough to find a particular position.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __nth     Another iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Rearranges the elements in the range @p [__first,__last) so that @p *__nth
 *  is the same element that would have been in that position had the
 *  whole sequence been sorted. The elements either side of @p *__nth are
 *  not completely sorted, but for any iterator @e i in the range
 *  @p [__first,__nth) and any iterator @e j in the range @p [__nth,__last) it
 *  holds that *j < *i is false.
*/
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  inline void
  nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
		  _RandomAccessIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __nth);
    __glibcxx_requires_valid_range(__nth, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    if (__first == __last || __nth == __last)
return;

    std::__introselect(__first, __nth, __last,
	 std::__lg(__last - __first) * 2,
	 __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Sort a sequence just enough to find a particular position
 *         using a predicate for comparison.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __nth     Another iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  Nothing.
 *
 *  Rearranges the elements in the range @p [__first,__last) so that @p *__nth
 *  is the same element that would have been in that position had the
 *  whole sequence been sorted. The elements either side of @p *__nth are
 *  not completely sorted, but for any iterator @e i in the range
 *  @p [__first,__nth) and any iterator @e j in the range @p [__nth,__last) it
 *  holds that @p __comp(*j,*i) is false.
*/
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
		  _RandomAccessIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_RandomAccessIterator>::value_type,
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __nth);
    __glibcxx_requires_valid_range(__nth, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    if (__first == __last || __nth == __last)
return;

    std::__introselect(__first, __nth, __last,
	 std::__lg(__last - __first) * 2,
	 __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

/**
 *  @brief Sort the elements of a sequence.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Sorts the elements in the range @p [__first,__last) in ascending order,
 *  such that for each iterator @e i in the range @p [__first,__last-1),  
 *  *(i+1)<*i is false.
 *
 *  The relative ordering of equivalent elements is not preserved, use
 *  @p stable_sort() if this is needed.
*/
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  inline void
  sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Sort the elements of a sequence using a predicate for comparison.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  Nothing.
 *
 *  Sorts the elements in the range @p [__first,__last) in ascending order,
 *  such that @p __comp(*(i+1),*i) is false for every iterator @e i in the
 *  range @p [__first,__last-1).
 *
 *  The relative ordering of equivalent elements is not preserved, use
 *  @p stable_sort() if this is needed.
*/
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_RandomAccessIterator>::value_type,
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
{
 if (__comp(__first2, __first1))
   {
     *__result = *__first2;
     ++__first2;
   }
 else
   {
     *__result = *__first1;
     ++__first1;
   }
 ++__result;
}
    return std::copy(__first2, __last2,
       std::copy(__first1, __last1, __result));
  }

/**
 *  @brief Merges two sorted ranges.
 *  @ingroup sorting_algorithms
 *  @param  __first1  An iterator.
 *  @param  __first2  Another iterator.
 *  @param  __last1   Another iterator.
 *  @param  __last2   Another iterator.
 *  @param  __result  An iterator pointing to the end of the merged range.
 *  @return   An output iterator equal to @p __result + (__last1 - __first1)
 *            + (__last2 - __first2).
 *
 *  Merges the ranges @p [__first1,__last1) and @p [__first2,__last2) into
 *  the sorted range @p [__result, __result + (__last1-__first1) +
 *  (__last2-__first2)).  Both input ranges must be sorted, and the
 *  output range must not overlap with either of the input ranges.
 *  The sort is @e stable, that is, for equivalent elements in the
 *  two ranges, elements from the first range will always come
 *  before elements from the second.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  merge(_InputIterator1 __first1, _InputIterator1 __last1,
 _InputIterator2 __first2, _InputIterator2 __last2,
 _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)	
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__merge(__first1, __last1,
		     __first2, __last2, __result,
		     __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Merges two sorted ranges.
 *  @ingroup sorting_algorithms
 *  @param  __first1  An iterator.
 *  @param  __first2  Another iterator.
 *  @param  __last1   Another iterator.
 *  @param  __last2   Another iterator.
 *  @param  __result  An iterator pointing to the end of the merged range.
 *  @param  __comp    A functor to use for comparisons.
 *  @return   An output iterator equal to @p __result + (__last1 - __first1)
 *            + (__last2 - __first2).
 *
 *  Merges the ranges @p [__first1,__last1) and @p [__first2,__last2) into
 *  the sorted range @p [__result, __result + (__last1-__first1) +
 *  (__last2-__first2)).  Both input ranges must be sorted, and the
 *  output range must not overlap with either of the input ranges.
 *  The sort is @e stable, that is, for equivalent elements in the
 *  two ranges, elements from the first range will always come
 *  before elements from the second.
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  merge(_InputIterator1 __first1, _InputIterator1 __last1,
 _InputIterator2 __first2, _InputIterator2 __last2,
 _OutputIterator __result, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__merge(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _RandomAccessIterator, typename _Compare>
  inline void
  __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
  {
    typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
    typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;

    typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
    _TmpBuf __buf(__first, std::distance(__first, __last));

    if (__buf.begin() == 0)
std::__inplace_stable_sort(__first, __last, __comp);
    else
std::__stable_sort_adaptive(__first, __last, __buf.begin(),
		    _DistanceType(__buf.size()), __comp);
  }

/**
 *  @brief Sort the elements of a sequence, preserving the relative order
 *         of equivalent elements.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Sorts the elements in the range @p [__first,__last) in ascending order,
 *  such that for each iterator @p i in the range @p [__first,__last-1),
 *  @p *(i+1)<*i is false.
 *
 *  The relative ordering of equivalent elements is preserved, so any two
 *  elements @p x and @p y in the range @p [__first,__last) such that
 *  @p x<y is false and @p y<x is false will have the same relative
 *  ordering after calling @p stable_sort().
*/
template<typename _RandomAccessIterator>
  inline void
  stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    _GLIBCXX_STD_Astd::__stable_sort(__first, __last,
		    __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Sort the elements of a sequence using a predicate for comparison,
 *         preserving the relative order of equivalent elements.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  Nothing.
 *
 *  Sorts the elements in the range @p [__first,__last) in ascending order,
 *  such that for each iterator @p i in the range @p [__first,__last-1),
 *  @p __comp(*(i+1),*i) is false.
 *
 *  The relative ordering of equivalent elements is preserved, so any two
 *  elements @p x and @p y in the range @p [__first,__last) such that
 *  @p __comp(x,y) is false and @p __comp(y,x) is false will have the same
 *  relative ordering after calling @p stable_sort().
*/
template<typename _RandomAccessIterator, typename _Compare>
  inline void
  stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_RandomAccessIterator>::value_type,
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    _GLIBCXX_STD_Astd::__stable_sort(__first, __last,
		    __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
{
 if (__comp(__first1, __first2))
   {
     *__result = *__first1;
     ++__first1;
   }
 else if (__comp(__first2, __first1))
   {
     *__result = *__first2;
     ++__first2;
   }
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
   }
 ++__result;
}
    return std::copy(__first2, __last2,
       std::copy(__first1, __last1, __result));
  }

/**
 *  @brief Return the union of two sorted ranges.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  each range in order to the output range.  Iterators increment for each
 *  range.  When the current element of one range is less than the other,
 *  that element is copied and the iterator advanced.  If an element is
 *  contained in both ranges, the element from the first range is copied and
 *  both ranges advance.  The output range may not overlap either input
 *  range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_union(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__set_union(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Return the union of two sorted ranges using a comparison functor.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @param  __comp    The comparison functor.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  each range in order to the output range.  Iterators increment for each
 *  range.  When the current element of one range is less than the other
 *  according to @p __comp, that element is copied and the iterator advanced.
 *  If an equivalent element according to @p __comp is contained in both
 *  ranges, the element from the first range is copied and both ranges
 *  advance.  The output range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_union(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__set_union(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first1, __first2))
 ++__first1;
else if (__comp(__first2, __first1))
 ++__first2;
else
 {
   *__result = *__first1;
   ++__first1;
   ++__first2;
   ++__result;
 }
    return __result;
  }

/**
 *  @brief Return the intersection of two sorted ranges.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  both ranges in order to the output range.  Iterators increment for each
 *  range.  When the current element of one range is less than the other,
 *  that iterator advances.  If an element is contained in both ranges, the
 *  element from the first range is copied and both ranges advance.  The
 *  output range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__set_intersection(__first1, __last1,
		     __first2, __last2, __result,
		     __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Return the intersection of two sorted ranges using comparison
 *  functor.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @param  __comp    The comparison functor.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  both ranges in order to the output range.  Iterators increment for each
 *  range.  When the current element of one range is less than the other
 *  according to @p __comp, that iterator advances.  If an element is
 *  contained in both ranges according to @p __comp, the element from the
 *  first range is copied and both ranges advance.  The output range may not
 *  overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__set_intersection(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first1, __first2))
 {
   *__result = *__first1;
   ++__first1;
   ++__result;
 }
else if (__comp(__first2, __first1))
 ++__first2;
else
 {
   ++__first1;
   ++__first2;
 }
    return std::copy(__first1, __last1, __result);
  }

/**
 *  @brief Return the difference of two sorted ranges.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  the first range but not the second in order to the output range.
 *  Iterators increment for each range.  When the current element of the
 *  first range is less than the second, that element is copied and the
 *  iterator advances.  If the current element of the second range is less,
 *  the iterator advances, but no element is copied.  If an element is
 *  contained in both ranges, no elements are copied and both ranges
 *  advance.  The output range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)	
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__set_difference(__first1, __last1,
		   __first2, __last2, __result,
		   __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return the difference of two sorted ranges using comparison
 *  functor.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @param  __comp    The comparison functor.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  the first range but not the second in order to the output range.
 *  Iterators increment for each range.  When the current element of the
 *  first range is less than the second according to @p __comp, that element
 *  is copied and the iterator advances.  If the current element of the
 *  second range is less, no element is copied and the iterator advances.
 *  If an element is contained in both ranges according to @p __comp, no
 *  elements are copied and both ranges advance.  The output range may not
 *  overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__set_difference(__first1, __last1,
		   __first2, __last2, __result,
		   __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __set_symmetric_difference(_InputIterator1 __first1,
	       _InputIterator1 __last1,
	       _InputIterator2 __first2,
	       _InputIterator2 __last2,
	       _OutputIterator __result,
	       _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first1, __first2))
 {
   *__result = *__first1;
   ++__first1;
   ++__result;
 }
else if (__comp(__first2, __first1))
 {
   *__result = *__first2;
   ++__first2;
   ++__result;
 }
else
 {
   ++__first1;
   ++__first2;
 }
    return std::copy(__first2, __last2, 
       std::copy(__first1, __last1, __result));
  }

/**
 *  @brief  Return the symmetric difference of two sorted ranges.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  one range but not the other in order to the output range.  Iterators
 *  increment for each range.  When the current element of one range is less
 *  than the other, that element is copied and the iterator advances.  If an
 *  element is contained in both ranges, no elements are copied and both
 *  ranges advance.  The output range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
	     _InputIterator2 __first2, _InputIterator2 __last2,
	     _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)	
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__set_symmetric_difference(__first1, __last1,
			__first2, __last2, __result,
			__gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return the symmetric difference of two sorted ranges using
 *  comparison functor.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @param  __comp    The comparison functor.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  one range but not the other in order to the output range.  Iterators
 *  increment for each range.  When the current element of one range is less
 *  than the other according to @p comp, that element is copied and the
 *  iterator advances.  If an element is contained in both ranges according
 *  to @p __comp, no elements are copied and both ranges advance.  The output
 *  range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
	     _InputIterator2 __first2, _InputIterator2 __last2,
	     _OutputIterator __result,
	     _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__set_symmetric_difference(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  _ForwardIterator
  __min_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
  {
    if (__first == __last)
return __first;
    _ForwardIterator __result = __first;
    while (++__first != __last)
if (__comp(__first, __result))
 __result = __first;
    return __result;
  }

/**
 *  @brief  Return the minimum element in a range.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  Iterator referencing the first instance of the smallest value.
*/
template<typename _ForwardIterator>
  _GLIBCXX14_CONSTEXPRconstexpr
  _ForwardIterator
  inline min_element(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return _GLIBCXX_STD_Astd::__min_element(__first, __last,
		__gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return the minimum element in a range using comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   Comparison functor.
 *  @return  Iterator referencing the first instance of the smallest value
 *  according to __comp.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _ForwardIterator
  min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return _GLIBCXX_STD_Astd::__min_element(__first, __last,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  _ForwardIterator
  __max_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
  {
    if (__first == __last) return __first;
    _ForwardIterator __result = __first;
    while (++__first != __last)
if (__comp(__result, __first))
 __result = __first;
    return __result;
  }

/**
 *  @brief  Return the maximum element in a range.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  Iterator referencing the first instance of the largest value.
*/
template<typename _ForwardIterator>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _ForwardIterator
  max_element(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return _GLIBCXX_STD_Astd::__max_element(__first, __last,
		__gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return the maximum element in a range using comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   Comparison functor.
 *  @return  Iterator referencing the first instance of the largest value
 *  according to __comp.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _ForwardIterator
  max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return _GLIBCXX_STD_Astd::__max_element(__first, __last,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

5757#if __cplusplus201402L >= 201402L
/// Reservoir sampling algorithm.
template<typename _InputIterator, typename _RandomAccessIterator,
         typename _Size, typename _UniformRandomBitGenerator>
  _RandomAccessIterator
  __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
    _RandomAccessIterator __out, random_access_iterator_tag,
    _Size __n, _UniformRandomBitGenerator&& __g)
  {
    using __distrib_type = uniform_int_distribution<_Size>;
    using __param_type = typename __distrib_type::param_type;
    __distrib_type __d{};
    _Size __sample_sz = 0;
    while (__first != __last && __sample_sz != __n)
{
 __out[__sample_sz++] = *__first;
 ++__first;
}
    for (auto __pop_sz = __sample_sz; __first != __last;
 ++__first, (void) ++__pop_sz)
{
 const auto __k = __d(__g, __param_type{0, __pop_sz});
 if (__k < __n)
   __out[__k] = *__first;
}
    return __out + __sample_sz;
  }

/// Selection sampling algorithm.
template<typename _ForwardIterator, typename _OutputIterator, typename _Cat,
         typename _Size, typename _UniformRandomBitGenerator>
  _OutputIterator
  __sample(_ForwardIterator __first, _ForwardIterator __last,
    forward_iterator_tag,
    _OutputIterator __out, _Cat,
    _Size __n, _UniformRandomBitGenerator&& __g)
  {
    using __distrib_type = uniform_int_distribution<_Size>;
    using __param_type = typename __distrib_type::param_type;
    using _USize = make_unsigned_t<_Size>;
    using _Gen = remove_reference_t<_UniformRandomBitGenerator>;
    using __uc_type = common_type_t<typename _Gen::result_type, _USize>;

    if (__first == __last)
return __out;

    __distrib_type __d{};
    _Size __unsampled_sz = std::distance(__first, __last);
    __n = std::min(__n, __unsampled_sz);

    // If possible, we use __gen_two_uniform_ints to efficiently produce
    // two random numbers using a single distribution invocation:

    const __uc_type __urngrange = __g.max() - __g.min();
    if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz))
      // I.e. (__urngrange >= __unsampled_sz * __unsampled_sz) but without
// wrapping issues.
      {
 while (__n != 0 && __unsampled_sz >= 2)
   {
     const pair<_Size, _Size> __p =
__gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g);

     --__unsampled_sz;
     if (__p.first < __n)
{
  *__out++ = *__first;
  --__n;
}

     ++__first;

     if (__n == 0) break;

     --__unsampled_sz;
     if (__p.second < __n)
{
  *__out++ = *__first;
  --__n;
}

     ++__first;
   }
      }

    // The loop above is otherwise equivalent to this one-at-a-time version:

    for (; __n != 0; ++__first)
if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
 {
   *__out++ = *__first;
   --__n;
 }
    return __out;
  }

5853#if __cplusplus201402L > 201402L
5854#define __cpp_lib_sample 201603
/// Take a random sample from a population.
template<typename _PopulationIterator, typename _SampleIterator,
         typename _Distance, typename _UniformRandomBitGenerator>
  _SampleIterator
  sample(_PopulationIterator __first, _PopulationIterator __last,
  _SampleIterator __out, _Distance __n,
  _UniformRandomBitGenerator&& __g)
  {
    using __pop_cat = typename
std::iterator_traits<_PopulationIterator>::iterator_category;
    using __samp_cat = typename
std::iterator_traits<_SampleIterator>::iterator_category;

    static_assert(
 __or_<is_convertible<__pop_cat, forward_iterator_tag>,
is_convertible<__samp_cat, random_access_iterator_tag>>::value,
 "output range must use a RandomAccessIterator when input range"
 " does not meet the ForwardIterator requirements");

    static_assert(is_integral<_Distance>::value,
    "sample size must be an integer type");

    typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
    return _GLIBCXX_STD_Astd::
__sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
 std::forward<_UniformRandomBitGenerator>(__g));
  }
5882#endif // C++17
5883#endif // C++14

5885_GLIBCXX_END_NAMESPACE_ALGO
5886_GLIBCXX_END_NAMESPACE_VERSION
5887} // namespace std

5889#endif /* _STL_ALGO_H */