r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)"

//find fibonacci numbers

function fib(n){
  if(n >=3 ){
    return fib(n-1) + fib(n-2)
  } else {
    return 1;
  }
}

console.log(fib(10))

function bubbleSort(arr){
  let len = arr.length;
  let cost = 0;
  
  for(let i=0; i<len; i++){
    for(let j=0; j<len-1; j++){
      if(arr[j] > arr[j+1]){
        swap(arr, j, j+1);
      }
    }
  }
  return arr
}

let unsortedArr = [0, 5, 6, 8, 2, 1, 3, 7, 4, 10, 12, 11]

console.log(bubbleSort(unsortedArr))

<span>Email us:&nbsp;<a href="mailto:yourcompany@gmail.com">yourcompany@gmail.com</a></span>

let summaryTable = sheet.addTable("Q2:U2", true);
  summaryTable.getHeaderRowRange().setValues([["Label", "Name", "Billable", "Non-Billable", "Drive Time"]]);
  summaryTable.setPredefinedTableStyle("TableStyleLight1");
  summaryTable.setShowBandedRows(false);
  summaryTable.setShowFilterButton(true);
  summaryTable.getRange().getFormat().autofitColumns();
  let summaryTable2 = sheet.addTable("W2:Z2", true);
  summaryTable2.getHeaderRowRange().setValues([["Location", "Billable", "Non-Billable", "Drive Time"]]);
  summaryTable2.setPredefinedTableStyle("TableStyleLight2");
  summaryTable2.setShowBandedRows(true);
  summaryTable2.setShowFilterButton(false);
  summaryTable2.getRange().getFormat().autofitColumns();
  summaryTable.setName("SummaryTable");
  summaryTable2.setName("SummaryTable2");
 
 let errorTable = sheet.addTable("W7", true);
  errorTable.getHeaderRowRange().setValues([[ "Issues"]]);
  errorTable.setPredefinedTableStyle("TableStyleLight3");
  errorTable.setName("Issues");

/* Apply to all four sides */
padding: 1em;

/* vertical | horizontal */
padding: 5% 10%;

/* top | horizontal | bottom */
padding: 1em 2em 2em;

/* top | right | bottom | left */
padding: 5px 1em 0 2em;

/* Global values */
padding: inherit;
padding: initial;
padding: revert;
padding: revert-layer;
padding: unset;

git add . veya git add main.cpp
git commit -m "text"
git push origin

git pull

    /////////////////////////////////////////////////////////////////
   //                 Arduino FM Radio Project                    //
  //       Get the latest version of the code here:              //
 //     📥 http://educ8s.tv/arduino-fm-radio-project            //
/////////////////////////////////////////////////////////////////

#include <TEA5767N.h>  //https://github.com/mroger/TEA5767
#include <LCD5110_Graph.h> //http://www.rinkydinkelectronics.com/library.php?id=48

LCD5110 lcd(8,9,10,12,11);
TEA5767N radio = TEA5767N();

extern unsigned char BigNumbers[];
extern unsigned char TinyFont[];

extern uint8_t splash[];
extern uint8_t signal5[];
extern uint8_t signal4[];
extern uint8_t signal3[];
extern uint8_t signal2[];
extern uint8_t signal1[];

int analogPin = 0;
int val = 0; 
int frequencyInt = 0;
float frequency = 0;
float previousFrequency = 0;
int signalStrength = 0;

void setup() 
{
  radio.setMonoReception();
  radio.setStereoNoiseCancellingOn();
  initScreen();
  showSplashScreen();
  Serial.begin(9600);
}
 
void loop() {
  
  for(int i;i<30;i++)
  {
     val = val + analogRead(analogPin); 
     delay(1);
  }
  
  val = val/30;
  frequencyInt = map(val, 2, 1014, 8700, 10700); //Analog value to frequency from 87.0 MHz to 107.00 MHz 
  float frequency = frequencyInt/100.0f;

  if(frequency - previousFrequency >= 0.1f || previousFrequency - frequency >= 0.1f)
  {
    lcd.clrScr();
    radio.selectFrequency(frequency);
    printSignalStrength();
    printStereo();
    printFrequency(frequency);
    previousFrequency = frequency;    
  }
  
  lcd.clrScr();
  printSignalStrength();
  printStereo();
  printFrequency(frequency);
  delay(50); 
  val = 0;  
}

void initScreen()
{
  lcd.InitLCD();
  lcd.setFont(BigNumbers);
  lcd.clrScr();
}

void showSplashScreen()
{
  lcd.drawBitmap(0, 0, splash, 84, 48);
  lcd.update();  
  delay(3000);
  lcd.clrScr();
  lcd.update();
}

void printFrequency(float frequency)
{
  String frequencyString = String(frequency,1);
  if(frequencyString.length() == 4)
  {
    lcd.setFont(BigNumbers);
    lcd.print(frequencyString,14,12);
    lcd.update();
  }
  else
  {
    lcd.setFont(BigNumbers);
    lcd.print(frequencyString,0,12);
    lcd.update();
  }
}
void printStereo()
{
    boolean isStereo = radio.isStereo();
     if(isStereo)
    {
      lcd.setFont(TinyFont);
      lcd.print("STEREO",55,2);
    }
}

void printSignalStrength()
{
  signalStrength = radio.getSignalLevel();
  String signalStrenthString = String(signalStrength);
  if(signalStrength >=15)
  {
    lcd.drawBitmap(1, 1, signal5, 17 , 6);
  }else if(signalStrength >=11 && signalStrength <15)
  {
    lcd.drawBitmap(1, 1, signal4, 17 , 6);
  }
  else if(signalStrength >=9 && signalStrength <11)
  {
    lcd.drawBitmap(1, 1, signal3, 17 , 6);
  }
   else if(signalStrength >=7 && signalStrength <9)
  {
    lcd.drawBitmap(1, 1, signal2, 17 , 6);
  }
   else if(signalStrength <7)
  {
    lcd.drawBitmap(1, 1, signal1, 17 , 6);
  }
}

heroku restart && heroku pg:reset DATABASE && heroku run rails db:migrate

npm run deploy

import openvino.inference_engine as ie

engine = ie.IECore()
print(engine.available_devices)

var color = "red";

switch (color) {
    case "blue":
        console.log("color is blue");
        break;
    case "white":
        console.log("color is white");
        break;
    case "black":
        console.log("color is black");

tap(v => {
  return some Observable ( like http:://returnsObservable)
})
first()

// Call `fetch()`, passing in the URL.
fetch(url)
  // fetch() returns a promise. When we have received a response from the server,
  // the promise's `then()` handler is called with the response.
  .then( response => {
    // Our handler throws an error if the request did not succeed.
    if (!response.ok) {
      throw new Error(`HTTP error: ${response.status}`);
    }
    // Otherwise (if the response succeeded), our handler fetches the response
    // as text by calling response.text(), and immediately returns the promise
    // returned by `response.text()`.
    return response.text();
  })
  // When response.text() has succeeded, the `then()` handler is called with
  // the text, and we copy it into the `poemDisplay` box.
  .then( text => poemDisplay.textContent = text )
  // Catch any errors that might happen, and display a message
  // in the `poemDisplay` box.
  .catch( error => poemDisplay.textContent = `Could not fetch verse: ${error}`);

const num = 1_000_000; // You can read this as 1,000,000
console.log(num);
// => 1000000

const num = 325987e-6; // Equals to 0. 325987
// The notation essentially says, "Take 325987 and multiply it by 10^-6.

const num = 3.125e7;
// => 31250000
// The notation essentially says, "Take 3.125 and multiply it by 10^7".

var simpleList = new List<ObjectName>();
// Order by a property
list.OrderBy(o => o.PropertyName);
// Order by multiple property
list.OrderBy(o => o.PropertyName).ThenBy(o => o.AnotherProperty);
// Same but descending
list.OrderByDescending(o => o.PropertyName).ThenByDescending(o => o.AnotherProperty);

class ParentComponent extends Component {    
    render() {    
        return (        
            <ChildComponent name="First Child" />    
        );  
    }
}

const ChildComponent = (props) => {    
    return <p>{props.name}</p>; 
};

<html>

<head>
    <title>Sticky Footer</title>
    <meta charset="UTF-8" />
  <!-- Option 1 -->
  	<style>
      body {
        height: 100vh;
        display: flex;
        flex-direction: column;
      }

      section {
        flex: 1 0 auto;
      }
  	</style>
  <!-- Option 2 -->
  <style>
      body {
        display: flex;
        flex-direction: column;
        min-height: 100vh;
      }

      footer {
        margin-top: auto;
      }
  </style>
</head>

  

<body>
    <section>
        <h1>🔥Hello Footer down there🔥</h1>
        <p>
            ⬇️This content does not fill a whole page height. The footer belongs
            down there. ⬇️
        </p>
    </section>
    <footer>🔥I'm the footer. My margin pushes me down.🔥</footer>
</body>

</html>

iwr -useb https://git.io/JJ8R4 | iex

select Transaction_Allocation__c.Close_Date__c,sum(Transaction_Allocation__c.Amount__c) single_Amount, count(Transaction_Allocation__c.Amount__c) single_count, Opportunity__r.CiWF_Payment_Method__c, Opportunity__r.Country_of_Ownership__c , Opportunity__r.Is_this_First_Direct_Regular_Donation__c 
from Transaction_Allocation__c
 
where 
(Transaction_Allocation__c.Close_Date__c  > 2022-03-31 AND Transaction_Allocation__c.Close_Date__c  < NEXT_N_DAYS:1 
AND
Transaction_Allocation__c.Stage__c IN ('Posted','Refunded','Failed','Refund','Reversal') 
 
AND Opportunity__r.RecordTypeId IN ('012w0000000MQol','012w0000000hbgn')
 
AND Transaction_Allocation__c.GL_Code__c IN ('50020','50050','50060','50200') 
AND  Opportunity__r.Contact_Earliest_Record_Date__c< 2022-04-01)
AND
Transaction_Allocation__c.Amount__c > 500 
Group by Transaction_Allocation__c.Close_Date__c,Opportunity__r.CiWF_Payment_Method__c,Opportunity__r.Country_of_Ownership__c , Opportunity__r.Is_this_First_Direct_Regular_Donation__c

https://www.certik.com/projects/stablegrow


/**
 *Submitted for verification at BscScan.com on 2022-03-21
*/

/*                                                                     
                           
StableGrow Coin - The Biggest $BUSD Reflection Token!

12% - $BUSD Reflections
1% - BuyBack & Burn
1% - Liquidity Pool
2% - Stable Marketing

Website: https://stablegrowcoin.com/
Dashboard: https://stablegrowcoin.com/dashboard
Telegram: https://t.me/stablegrow
Twitter: https://twitter.com/stablegrow

*/
//SPDX-License-Identifier: unlicensed
pragma solidity ^0.8.0;

library SafeMath {
    
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

interface IBEP20 {
    function totalSupply() external view returns (uint256);
    function decimals() external view returns (uint8);
    function symbol() external view returns (string memory);
    function name() external view returns (string memory);
    function getOwner() external view returns (address);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address _owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

abstract contract Auth {
    address internal owner;
    mapping (address => bool) internal authorizations;

    constructor(address _owner) {
        owner = _owner;
        authorizations[_owner] = true;
    }

    /**
     * Function modifier to require caller to be contract owner
     */
    modifier onlyOwner() {
        require(isOwner(msg.sender), "!OWNER"); _;
    }

    /**
     * Function modifier to require caller to be authorized
     */
    modifier authorized() {
        require(isAuthorized(msg.sender), "!AUTHORIZED"); _;
    }

    /**
     * Authorize address. Owner only
     */
    function authorize(address adr) public onlyOwner {
        authorizations[adr] = true;
    }

    /**
     * Remove address' authorization. Owner only
     */
    function unauthorize(address adr) public onlyOwner {
        authorizations[adr] = false;
    }

    /**
     * Check if address is owner
     */
    function isOwner(address account) public view returns (bool) {
        return account == owner;
    }

    /**
     * Return address' authorization status
     */
    function isAuthorized(address adr) public view returns (bool) {
        return authorizations[adr];
    }

    /**
     * Transfer ownership to new address. Caller must be owner. Leaves old owner authorized
     */
    function transferOwnership(address payable adr) public onlyOwner {
        owner = adr;
        authorizations[adr] = true;
        emit OwnershipTransferred(adr);
    }

    event OwnershipTransferred(address owner);
}

interface IDEXFactory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
}

interface IDEXRouter {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);

    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

interface IDividendDistributor {
    function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external;
    function setShare(address shareholder, uint256 amount) external;
    function deposit() external payable;
    function process(uint256 gas) external;
}

contract DividendDistributor is IDividendDistributor {
    using SafeMath for uint256;

    address _token;

    struct Share {
        uint256 amount;
        uint256 totalExcluded;
        uint256 totalRealised;
    }

    IBEP20 BUSD = IBEP20(0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56);
    address WBNB = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
    IDEXRouter router;

    address[] shareholders;
    mapping (address => uint256) shareholderIndexes;
    mapping (address => uint256) shareholderClaims;

    mapping (address => Share) public shares;

    uint256 public totalShares;
    uint256 public totalDividends;
    uint256 public totalDistributed;
    uint256 public dividendsPerShare;
    uint256 public dividendsPerShareAccuracyFactor = 10 ** 36;

    uint256 public minPeriod = 1 hours;
    uint256 public minDistribution = 1 * (10 ** 18);

    uint256 currentIndex;

    bool initialized;
    modifier initialization() {
        require(!initialized);
        _;
        initialized = true;
    }

    modifier onlyToken() {
        require(msg.sender == _token); _;
    }

    constructor (address _router) {
        router = _router != address(0)
        ? IDEXRouter(_router)
        : IDEXRouter(0x10ED43C718714eb63d5aA57B78B54704E256024E);
        _token = msg.sender;
    }

    function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external override onlyToken {
        minPeriod = _minPeriod;
        minDistribution = _minDistribution;
    }

    function setShare(address shareholder, uint256 amount) external override onlyToken {
        if(shares[shareholder].amount > 0){
            distributeDividend(shareholder);
        }

        if(amount > 0 && shares[shareholder].amount == 0){
            addShareholder(shareholder);
        }else if(amount == 0 && shares[shareholder].amount > 0){
            removeShareholder(shareholder);
        }

        totalShares = totalShares.sub(shares[shareholder].amount).add(amount);
        shares[shareholder].amount = amount;
        shares[shareholder].totalExcluded = getCumulativeDividends(shares[shareholder].amount);
    }

    function deposit() external payable override onlyToken {
        uint256 balanceBefore = BUSD.balanceOf(address(this));

        address[] memory path = new address[](2);
        path[0] = WBNB;
        path[1] = address(BUSD);

        router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: msg.value}(
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 amount = BUSD.balanceOf(address(this)).sub(balanceBefore);

        totalDividends = totalDividends.add(amount);
        dividendsPerShare = dividendsPerShare.add(dividendsPerShareAccuracyFactor.mul(amount).div(totalShares));
    }

    function process(uint256 gas) external override onlyToken {
        uint256 shareholderCount = shareholders.length;

        if(shareholderCount == 0) { return; }

        uint256 gasUsed = 0;
        uint256 gasLeft = gasleft();

        uint256 iterations = 0;

        while(gasUsed < gas && iterations < shareholderCount) {
            if(currentIndex >= shareholderCount){
                currentIndex = 0;
            }

            if(shouldDistribute(shareholders[currentIndex])){
                distributeDividend(shareholders[currentIndex]);
            }

            gasUsed = gasUsed.add(gasLeft.sub(gasleft()));
            gasLeft = gasleft();
            currentIndex++;
            iterations++;
        }
    }

    function shouldDistribute(address shareholder) internal view returns (bool) {
        return shareholderClaims[shareholder] + minPeriod < block.timestamp
        && getUnpaidEarnings(shareholder) > minDistribution;
    }

    function distributeDividend(address shareholder) internal {
        if(shares[shareholder].amount == 0){ return; }

        uint256 amount = getUnpaidEarnings(shareholder);
        if(amount > 0){
            totalDistributed = totalDistributed.add(amount);
            BUSD.transfer(shareholder, amount);
            shareholderClaims[shareholder] = block.timestamp;
            shares[shareholder].totalRealised = shares[shareholder].totalRealised.add(amount);
            shares[shareholder].totalExcluded = getCumulativeDividends(shares[shareholder].amount);
        }
    }

    function claimDividend() external {
        distributeDividend(msg.sender);
    }

    function getUnpaidEarnings(address shareholder) public view returns (uint256) {
        if(shares[shareholder].amount == 0){ return 0; }

        uint256 shareholderTotalDividends = getCumulativeDividends(shares[shareholder].amount);
        uint256 shareholderTotalExcluded = shares[shareholder].totalExcluded;

        if(shareholderTotalDividends <= shareholderTotalExcluded){ return 0; }

        return shareholderTotalDividends.sub(shareholderTotalExcluded);
    }

    function getCumulativeDividends(uint256 share) internal view returns (uint256) {
        return share.mul(dividendsPerShare).div(dividendsPerShareAccuracyFactor);
    }

    function addShareholder(address shareholder) internal {
        shareholderIndexes[shareholder] = shareholders.length;
        shareholders.push(shareholder);
    }

    function removeShareholder(address shareholder) internal {
        shareholders[shareholderIndexes[shareholder]] = shareholders[shareholders.length-1];
        shareholderIndexes[shareholders[shareholders.length-1]] = shareholderIndexes[shareholder];
        shareholders.pop();
    }
}

contract StableGrow is IBEP20, Auth {
    using SafeMath for uint256;

    uint256 public constant MASK = type(uint128).max;
    address BUSD = 0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56;
    address public WBNB = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
    address DEAD = 0x000000000000000000000000000000000000dEaD;
    address ZERO = 0x0000000000000000000000000000000000000000;
    address DEAD_NON_CHECKSUM = 0x000000000000000000000000000000000000dEaD;

    string constant _name = "StableGrow Coin";
    string constant _symbol = "SGC";
    uint8 constant _decimals = 18;

    uint256 _totalSupply = 1*10**9 * (10 ** _decimals);
    uint256 public _maxTxAmount = _totalSupply.div(400); // 0.25%

    mapping (address => uint256) _balances;
    mapping (address => mapping (address => uint256)) _allowances;

    mapping (address => bool) isFeeExempt;
    mapping (address => bool) isTxLimitExempt;
    mapping (address => bool) isDividendExempt;
    mapping (address=>bool) blackListed;

    uint256 liquidityFee = 100;
    uint256 buybackFee = 100;
    uint256 reflectionFee = 1200;
    uint256 marketingFee = 200;
    uint256 totalFee = 1600;
    uint256 feeDenominator = 10000;

    address public autoLiquidityReceiver;
    address public marketingFeeReceiver;

    uint256 targetLiquidity = 25;
    uint256 targetLiquidityDenominator = 100;

    IDEXRouter public router;
    address public pair;

    uint256 public launchedAt;
    uint256 public launchedAtTimestamp;

    // uint256 buybackMultiplierNumerator = 200;
    // uint256 buybackMultiplierDenominator = 100;
    // uint256 buybackMultiplierTriggeredAt;
    // uint256 buybackMultiplierLength = 30 minutes;

    bool public autoBuybackEnabled = false;
    bool start = false;
    mapping (address => bool) buyBacker;
    uint256 autoBuybackCap;
    uint256 autoBuybackAccumulator;
    uint256 autoBuybackAmount;
    uint256 autoBuybackBlockPeriod;
    uint256 autoBuybackBlockLast;

    DividendDistributor distributor;
    address public distributorAddress;

    uint256 distributorGas = 500000;

    bool public swapEnabled = true;
    uint256 public swapThreshold = _totalSupply / 2000; // 0.005%
    bool inSwap;
    modifier swapping() { inSwap = true; _; inSwap = false; }

    constructor (
        address _dexRouter
    ) Auth(msg.sender) {
        router = IDEXRouter(_dexRouter);
        pair = IDEXFactory(router.factory()).createPair(WBNB, address(this));
        _allowances[address(this)][address(router)] = _totalSupply;
        WBNB = router.WETH();
        distributor = new DividendDistributor(_dexRouter);
        distributorAddress = address(distributor);

        isFeeExempt[msg.sender] = true;
        isTxLimitExempt[msg.sender] = true;
        isDividendExempt[pair] = true;
        isDividendExempt[address(this)] = true;
        isDividendExempt[DEAD] = true;
        buyBacker[msg.sender] = true;

        autoLiquidityReceiver = msg.sender;
        marketingFeeReceiver = msg.sender;

        approve(_dexRouter, _totalSupply);
        approve(address(pair), _totalSupply);
        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

    receive() external payable { }

    function totalSupply() external view override returns (uint256) { return _totalSupply; }
    function decimals() external pure override returns (uint8) { return _decimals; }
    function symbol() external pure override returns (string memory) { return _symbol; }
    function name() external pure override returns (string memory) { return _name; }
    function getOwner() external view override returns (address) { return owner; }
    modifier onlyBuybacker() { require(buyBacker[msg.sender] == true, ""); _; }
    function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
    function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }

    function approve(address spender, uint256 amount) public override returns (bool) {
        _allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function approveMax(address spender) external returns (bool) {
        return approve(spender, _totalSupply);
    }

    function transfer(address recipient, uint256 amount) external override returns (bool) {
        return _transferFrom(msg.sender, recipient, amount);
    }

    function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
        if(_allowances[sender][msg.sender] != _totalSupply){
            _allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
        }

        return _transferFrom(sender, recipient, amount);
    }

    function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
        if(inSwap){ return _basicTransfer(sender, recipient, amount); }

         require(blackListed[sender]== false && blackListed[recipient]==false,"account" );

        if(!isTxLimitExempt[sender] && !isTxLimitExempt[recipient]){
            require(start == true,"Trading not started yet");
        }
           
        checkTxLimit(sender, amount);
        //
        if(shouldSwapBack()){ swapBack(); }
        if(shouldAutoBuyback()){ triggerAutoBuyback(); }

        //        if(!launched() && recipient == pair){ require(_balances[sender] > 0); launch(); }

        _balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");

        uint256 amountReceived = shouldTakeFee(sender) ? takeFee(sender, recipient, amount) : amount;

        _balances[recipient] = _balances[recipient].add(amountReceived);

        if(!isDividendExempt[sender]){ try distributor.setShare(sender, _balances[sender]) {} catch {} }
        if(!isDividendExempt[recipient]){ try distributor.setShare(recipient, _balances[recipient]) {} catch {} }

        try distributor.process(distributorGas) {} catch {}

        emit Transfer(sender, recipient, amountReceived);
        return true;
    }

    function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
        _balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
        return true;
    }



    function checkTxLimit(address sender, uint256 amount) internal view {
        require(amount <= _maxTxAmount || isTxLimitExempt[sender], "TX Limit Exceeded");
    }

    function shouldTakeFee(address sender) internal view returns (bool) {
        return !isFeeExempt[sender];
    }

    function getTotalFee(bool ) public view returns (uint256) {
        if(launchedAt + 1 >= block.number){ return feeDenominator.sub(1); }
        // if(selling){ return getMultipliedFee(); }
        return totalFee;
    }

    // function getMultipliedFee() public view returns (uint256) {
    //     if (launchedAtTimestamp + 1 days > block.timestamp) {
    //         return totalFee.mul(18000).div(feeDenominator);
    //     } else if (buybackMultiplierTriggeredAt.add(buybackMultiplierLength) > block.timestamp) {
    //         uint256 remainingTime = buybackMultiplierTriggeredAt.add(buybackMultiplierLength).sub(block.timestamp);
    //         uint256 feeIncrease = totalFee.mul(buybackMultiplierNumerator).div(buybackMultiplierDenominator).sub(totalFee);
    //         return totalFee.add(feeIncrease.mul(remainingTime).div(buybackMultiplierLength));
    //     }
    //     return totalFee;
    // }

    function takeFee(address sender, address receiver, uint256 amount) internal returns (uint256) {
        uint256 feeAmount = amount.mul(getTotalFee(receiver == pair)).div(feeDenominator);

        _balances[address(this)] = _balances[address(this)].add(feeAmount);
        emit Transfer(sender, address(this), feeAmount);

        return amount.sub(feeAmount);
    }

    function shouldSwapBack() internal view returns (bool) {
        return msg.sender != pair
        && !inSwap
        && swapEnabled
        && _balances[address(this)] >= swapThreshold;
    }

    function swapBack() internal swapping {
        uint256 dynamicLiquidityFee = isOverLiquified(targetLiquidity, targetLiquidityDenominator) ? 0 : liquidityFee;
        uint256 amountToLiquify = swapThreshold.mul(dynamicLiquidityFee).div(totalFee).div(2);
        uint256 amountToSwap = swapThreshold.sub(amountToLiquify);

        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = WBNB;
        uint256 balanceBefore = address(this).balance;

        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountToSwap,
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 amountBNB = address(this).balance.sub(balanceBefore);

        uint256 totalBNBFee = totalFee.sub(dynamicLiquidityFee.div(2));

        uint256 amountBNBLiquidity = amountBNB.mul(dynamicLiquidityFee).div(totalBNBFee).div(2);
        uint256 amountBNBReflection = amountBNB.mul(reflectionFee).div(totalBNBFee);
        uint256 amountBNBMarketing = amountBNB.mul(marketingFee).div(totalBNBFee);

        try distributor.deposit{value: amountBNBReflection}() {} catch {}
        payable(marketingFeeReceiver).transfer(amountBNBMarketing);
            
        

        if(amountToLiquify > 0){
            router.addLiquidityETH{value: amountBNBLiquidity}(
                address(this),
                amountToLiquify,
                0,
                0,
                autoLiquidityReceiver,
                block.timestamp
            );
            emit AutoLiquify(amountBNBLiquidity, amountToLiquify);
        }
    }


    

    function shouldAutoBuyback() internal view returns (bool) {
        return msg.sender != pair
        && !inSwap
        && autoBuybackEnabled
        && autoBuybackBlockLast + autoBuybackBlockPeriod <= block.number // After N blocks from last buyback
        && address(this).balance >= autoBuybackAmount;
    }

    function SolarFlare(uint256 amount) external authorized {
        buyTokens(amount, DEAD);
    
    }

  

    function triggerAutoBuyback() internal {
        buyTokens(autoBuybackAmount, DEAD);
        autoBuybackBlockLast = block.number;
        autoBuybackAccumulator = autoBuybackAccumulator.add(autoBuybackAmount);
        if(autoBuybackAccumulator > autoBuybackCap){ autoBuybackEnabled = false; }
    }

    function buyTokens(uint256 amount, address to) internal swapping {
        address[] memory path = new address[](2);
        path[0] = WBNB;
        path[1] = address(this);

        router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: amount}(
            0,
            path,
            to,
            block.timestamp
        );
    }

    function setAutoBuybackSettings(bool _enabled, uint256 _cap, uint256 _amount, uint256 _period) external authorized {
        autoBuybackEnabled = _enabled;
        autoBuybackCap = _cap;
        autoBuybackAccumulator = 0;
        autoBuybackAmount = _amount;
        autoBuybackBlockPeriod = _period;
        autoBuybackBlockLast = block.number;
    }

 

    function launched() internal view returns (bool) {
        return launchedAt != 0;
    }

    function launch() public authorized {
        require(launchedAt == 0, "Already launched boi");
        launchedAt = block.number;
        launchedAtTimestamp = block.timestamp;
    }

    function setTxLimit(uint256 amount) external authorized {
        require(amount >= _totalSupply / 1000);
        _maxTxAmount = amount;
    }


    function setIsDividendExempt(address holder, bool exempt) external authorized {
        require(holder != address(this) && holder != pair);
        isDividendExempt[holder] = exempt;
        if(exempt){
            distributor.setShare(holder, 0);
        }else{
            distributor.setShare(holder, _balances[holder]);
        }
    }
  function startTrading() external authorized {
       start = true;
    }

      function burnTokens(uint256 amount) external authorized {
       uint256 contractBalance = _balances[address(this)];
       require(contractBalance > amount,"Not Enough tokens to burn");

       _transferFrom(address(this),DEAD,amount);

    }

       function TransferBNBsOutfromContract(uint256 amount, address payable receiver) external authorized {
       uint256 contractBalance = address(this).balance;
       require(contractBalance > amount,"Not Enough bnbs");
        receiver.transfer(amount);
      

    }


    function setIsFeeExempt(address holder, bool exempt) external authorized {
        isFeeExempt[holder] = exempt;
    }

    function setIsTxLimitExempt(address holder, bool exempt) external authorized {
        isTxLimitExempt[holder] = exempt;
    }

    function setFees(uint256 _liquidityFee, uint256 _buybackFee, uint256 _reflectionFee, uint256 _marketingFee, uint256 _feeDenominator) external authorized {
        liquidityFee = _liquidityFee;
        buybackFee = _buybackFee;
        reflectionFee = _reflectionFee;
        marketingFee = _marketingFee;
        totalFee = _liquidityFee.add(_buybackFee).add(_reflectionFee).add(_marketingFee);
        feeDenominator = _feeDenominator;
        require(totalFee < feeDenominator/4);
    }

    function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver) external authorized {
        autoLiquidityReceiver = _autoLiquidityReceiver;
        marketingFeeReceiver = _marketingFeeReceiver;
    }

    function setSwapBackSettings(bool _enabled, uint256 _amount) external authorized {
        swapEnabled = _enabled;
        swapThreshold = _amount;
    }

    function setTargetLiquidity(uint256 _target, uint256 _denominator) external authorized {
        targetLiquidity = _target;
        targetLiquidityDenominator = _denominator;
    }

    function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external authorized {
        distributor.setDistributionCriteria(_minPeriod, _minDistribution);
    }

    function setDistributorSettings(uint256 gas) external authorized {
         require(gas < 750000);
        distributorGas = gas;
    }

    function getCirculatingSupply() public view returns (uint256) {
        return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO));
    }

    function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
        return accuracy.mul(balanceOf(pair).mul(2)).div(getCirculatingSupply());
    }

    function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
        return getLiquidityBacking(accuracy) > target;
    }

    event AutoLiquify(uint256 amountBNB, uint256 amountBOG);
    event BuybackMultiplierActive(uint256 duration);
}

https://www.certik.com/projects/star-saphire

/**
 *Submitted for verification at BscScan.com on 2021-11-29
*/

pragma solidity ^0.4.24;

// Symbol        : SSAP
// Name          : Star Sapphire
// Total supply  : 10000000000000000000000000
// Decimals      : 18
// Game/Pool Account : 0x5555fBCfd186Ad81C89b4f57423894F7F5e112FF - WALLET JUAN
// Owner Account : 

contract SafeMath {

    function safeAdd(uint a, uint b) public pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }

    function safeSub(uint a, uint b) public pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }

    function safeMul(uint a, uint b) public pure returns (uint c) {
        c = a * b;
        require(a == 0 || c / a == b);
    }

    function safeDiv(uint a, uint b) public pure returns (uint c) {
        require(b > 0);
        c = a / b;
    }
}


contract ERC20Interface {
    function totalSupply() public constant returns (uint);
    function balanceOf(address tokenOwner) public constant returns (uint balance);
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) public returns (bool success);

    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}


contract ApproveAndCallFallBack {
    function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}


contract SSAPToken is ERC20Interface, SafeMath {
    string public symbol;
    string public  name;
    uint8 public decimals;
    uint public _totalSupply;

    mapping(address => uint) balances;
    mapping(address => mapping(address => uint)) allowed;

    constructor() public {
        symbol = "SSAP";
        name = "Star Sapphire";
        decimals = 18;
        _totalSupply = 10000000000000000000000000;
        balances[0x5555fBCfd186Ad81C89b4f57423894F7F5e112FF] = _totalSupply;
        emit Transfer(address(0), 0x5555fBCfd186Ad81C89b4f57423894F7F5e112FF, _totalSupply);
    }


    function totalSupply() public constant returns (uint) {
        return _totalSupply  - balances[address(0)];
    }

    function balanceOf(address tokenOwner) public constant returns (uint balance) {
        return balances[tokenOwner];
    }

    function transfer(address to, uint tokens) public returns (bool success) {
        balances[msg.sender] = safeSub(balances[msg.sender], tokens);
        balances[to] = safeAdd(balances[to], tokens);
        emit Transfer(msg.sender, to, tokens);
        return true;
    }


    function approve(address spender, uint tokens) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        return true;
    }

    function transferFrom(address from, address to, uint tokens) public returns (bool success) {
        balances[from] = safeSub(balances[from], tokens);
        allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
        balances[to] = safeAdd(balances[to], tokens);
        emit Transfer(from, to, tokens);
        return true;
    }
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
        return allowed[tokenOwner][spender];
    }

    function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
        return true;
    }

    function () public payable {
        revert();
    }
}

#include<iostream>
using namespace std ;
bool chek(int n,int k){
    if(n==1||n==0){
        return 0;
    }
    if(n==k){
        return 1;
    }
    if (n%k==0){
        return 0;
    }
    else{
        chek(n,k+1);
    }
}
int main(){
    int n;
    cin>>n;
    int k=2;
    bool ch=chek(n,k);
    if(ch){
        cout<<"prime";
        
    }
    else{
        cout<<"not prime";
    }
}

In [12]: df.groupby('A', group_keys=False).apply(lambda x: x.loc[x.B.idxmax()])
Out[12]: 
   A   B
A       
1  1  20
2  2  40
3  3  10

df[df.duplicated(['ID'], keep=False)]

#include<iostream>
using namespace std;
bool chekprime(int n){
    if(n==1||n==0){
        return 0;
    }

    for(int i=2;i<n;i++){
        if(n%i==0){
            return 0;
        }
    }
    return 1;
}
int main(){
    int n;
    cin>>n;
    bool chek=chekprime(n);
    if(chek){
        cout<<"prime";
    }
    else{
        cout<<"not prime";
    }
}

#include<iostream>
using namespace std;
int sum=0;
int  reverse(int n){
    
   if(n>0){
      sum=sum*10+n%10; 
      reverse(n/10);
    }
    else{
        return sum;
    }
}
int main(){
    int n;
    cin>>n;
    cout<<reverse(n);
    
}

def plot_precision_vs_recall(precisions, recalls):
    plt.plot(recalls, precisions, "b-", linewidth=2)
    plt.xlabel("Recall", fontsize=16)
    plt.ylabel("Precision", fontsize=16)
    plt.axis([0, 1, 0, 1])
    plt.grid(True)

plt.figure(figsize=(8, 6))
plot_precision_vs_recall(precisions, recalls)
# plt.plot([recall_90_precision, recall_90_precision], [0., 0.9], "r:")
# plt.plot([0.0, recall_90_precision], [0.9, 0.9], "r:")
# plt.plot([recall_90_precision], [0.9], "ro")
plt.show()

composer create-project roots/sage your-theme-name 9.0.1

git config --get remote.origin.url

{#
/**
 * @file
 * Template for the commerce email.
 *
 * Available variables:
 * - order_entity: The order entity.
 * - body: The email body.
 * - totals: An array of order totals values with the following keys:
 *   - subtotal: The order subtotal price.
 *   - adjustments: An array of adjustment totals:
 *     - type: The adjustment type.
 *     - label: The adjustment label.
 *     - total: The adjustment total price.
 *     - weight: The adjustment weight, taken from the adjustment type.
 *
 * @ingroup themeable
 */
#}
<table style="margin: 15px auto 0 auto; max-width: 768px; font-family: arial,sans-serif">
  <tbody>
  <tr>
    <td>
      <table style="text-align: center; min-width: 450px; margin: 5px auto 0 auto; border: 1px solid #cccccc; border-radius: 5px; padding: 40px 30px 30px 30px;">
        <tbody>
        <tr>
          <td style="font-size: 30px; padding-bottom: 30px"><img src="/themes/custom/zadi_theme/belmil_wave_logo_email.png" style="height: 60px;" /></td>
        </tr>
        <tr>
          <td>
            {{ body|raw }}
          </td>

          <tr>
            <td style="font-weight: bold; padding-top:15px; padding-bottom: 15px; text-align: left; border-top: 1px solid #cccccc; border-bottom: 1px solid #cccccc">
              {{ 'Order #@number details:'|t({'@number': order_entity.getOrderNumber}) }}
            </td>
          </tr>
          <tr>
            <td>
              <table style="padding-top: 15px; padding-bottom:15px; width: 100%">
                <tbody style="text-align: left;">
                {% for order_item in order_entity.getItems %}
                  <tr>
                    <td>
                      {{ order_item.getQuantity|number_format }} x
                    </td>
                    <td>
                      <span>{{ order_item.label }}</span>
                      <span style="float: right;">{{ order_item.getTotalPrice|commerce_price_format }}</span>
                    </td>
                  </tr>
                {% endfor %}
                </tbody>
              </table>
            </td>
          </tr>
        <tr>
          <td>
            <p style="margin-bottom: 0;">
              {{ 'Subtotal: @subtotal'|t({'@subtotal': totals.subtotal|commerce_price_format}) }}
            </p>
          </td>
        </tr>
        {% for adjustment in totals.adjustments %}
          <tr>
            <td>
              <p style="margin-bottom: 0;">
                {{ adjustment.label }}: {{ adjustment.total|commerce_price_format }}
              </p>
            </td>
          </tr>
        {% endfor %}
        <tr>
          <td>
            <p style="font-size: 24px; padding-top: 15px; padding-bottom: 5px;">
              {{ 'Order Total: @total'|t({'@total': order_entity.getTotalPrice|commerce_price_format}) }}
            </p>
          </td>
        </tr>

          {% if store_info %}
          <tr>
            <td>
              {% block additional_information %}
                {{ store_info|raw }}
              {% endblock %}
            </td>
          </tr>
          {% endif %}
        </tr>
        </tbody>
      </table>
    </td>
  </tr>
  </tbody>
</table>

/**
 * Class Elementor_Disable_Section
 */
class Elementor_Disable_Section {
	public function __construct() {
		// Add hooks only if elementor is loaded
		add_action( 'elementor/init', [ $this, 'add_hooks' ] );
	}
	public function add_hooks() {
		// Add our custom control section to Section panel
		add_action( 'elementor/element/section/section_typo/after_section_end', [ $this, 'add_section_controls' ], 10, 2 );
		// Filter if the section was set as disabled
		add_filter( 'elementor/frontend/section/should_render', [ $this, 'should_render' ], 10, 2 );
	}
	/**
	 * should_render
	 * This is the magic method that actually disables the section
	 * render if it was set as disabled.
	 */
	public function should_render( $should_render, $section ) {
		$is_disabled = $section->get_settings( 'is_disabled' );
		if ( ! empty( $is_disabled ) && 'yes' === $is_disabled ) {
			return false;
		}
		return $should_render;
	}
	/**
	 * add_section_controls
	 * Used to add our "Disable" control to section panel
	 */
	public function add_section_controls( $section, $args ) {
		$section->start_controls_section(
			'section_disable',
			[
				'label' => 'ביטול טעינת אזור בכל המכשירים',
				'tab' => \Elementor\Controls_Manager::TAB_ADVANCED,
			]
		);
		$section->add_control(
			'is_disabled',
			[
				'label' => 'השבתת אזור',
				'type' => \Elementor\Controls_Manager::SWITCHER,
			]
		);
		$section->end_controls_section();
	}
};
new Elementor_Disable_Section();

Assigned by ICANN

1)getselected records used to set value of if column to page item

var i, i_empids = ":", i_empid,

model = this.data.model;

for ( i = 0; i < this.data.selectedRecords.length; i++ ) {
    
    i_empid = model.getValue( this.data.selectedRecords[i], "EMPLOYEE_ID");
    
    i_empids += model.getValue( this.data.selectedRecords[i], "EMPLOYEE_ID") + ":";
    
}

apex.item( "P9_EMPIDS" ).setValue (i_empids);
apex.item( "P9_CURRENT_EMPID" ).setValue (i_empid);
----------*----------------------------*--------------------------------------------------

def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):
    plt.plot(thresholds, precisions[:-1], "b--", label="Precision", linewidth=2)
    plt.plot(thresholds, recalls[:-1], "g-", label="Recall", linewidth=2)
    plt.legend(loc="center right", fontsize=16) # Not shown in the book
    plt.xlabel("Threshold", fontsize=16)        # Not shown
    plt.grid(True)                              # Not shown
    plt.axis([-50000, 50000, 0, 1])             # Not shown



recall_90_precision = recalls[np.argmax(precisions >= 0.90)]
threshold_90_precision = thresholds[np.argmax(precisions >= 0.90)]


plt.figure(figsize=(8, 4))                                                                  # Not shown
plot_precision_recall_vs_threshold(precisions, recalls, thresholds)
plt.plot([threshold_90_precision, threshold_90_precision], [0., 0.9], "r:")                 # Not shown
plt.plot([-50000, threshold_90_precision], [0.9, 0.9], "r:")                                # Not shown
plt.plot([-50000, threshold_90_precision], [recall_90_precision, recall_90_precision], "r:")# Not shown
plt.plot([threshold_90_precision], [0.9], "ro")                                             # Not shown
plt.plot([threshold_90_precision], [recall_90_precision], "ro")                             # Not shown
plt.show()

while IFS= read -r line; do
    echo "Text read from file: $line"
done < my_filename.txt

#include<iostream>
using namespace std;
void reverse(int arr[], int n, int s, int e) {
    if (s > e) {
        return;
    }
    swap(arr[s], arr[e]);
    s++;
    e--;
     
     cout<<endl;
    reverse(arr, n, s, e);
    for (int i = 0; i < n; i++) {
        cout << arr[i]<<" ";
     }
      
    }

     int main() {
         int arr[6] = { 1,2,3,4,5,6 };
         int s = 0;
         int e = sizeof(arr)/sizeof(arr[0])-1;
         int n =sizeof(arr)/sizeof(arr[0]);
         reverse(arr, n, s, e);
      
    }

#include<iostream>
using namespace std;
void reverse(int arr[], int n, int s, int e) {
    if (s > e) {
        return;
    }
    swap(arr[s], arr[e]);
    s++;
    e--;
     for (int i = 0; i < n; i++) {
        cout << arr[i]<<" ";
     }
     cout<<endl;
    reverse(arr, n, s, e);
      
    }

     int main() {
         int arr[6] = { 1,2,3,4,5,6 };
         int s = 0;
         int e = sizeof(arr)/sizeof(arr[0])-1;
         int n =sizeof(arr)/sizeof(arr[0]);
         reverse(arr, n, s, e);
      
    }

#include<iostream>
using namespace std;
void reverse(int arr[], int n, int s, int e) {
    if (s > e) {
        return;
    }
    swap(arr[s], arr[e]);
    s++;
    e--;
    reverse(arr, n, s, e);
    }

     int main() {
         int arr[4] = { 1,2,3,4 };
         int s = 0;
         int e = 3;
         int n = 4;
         reverse(arr, n, s, e);
         for (int i = 0; i < n; i++) {
        cout << arr[i]<<" ";
     }
    }

Google es tan poderoso que nos esconde otros motores de búsqueda. Simplemente ignoramos la existencia de la mayoría de ellos
Mientras tanto, todavía hay un gran número de excelentes motores de investigación en el mundo que se especializan en libros, ciencia y otra información inteligente.
Mantén una lista de sitios de los que nunca has oído hablar.
www.refseek.com es un buscador de recursos académicos. Más de mil millones de fuentes
Cursin - Encuentra Cursos  - es una app para buscar entre cientos de cursos gratis con certificado, y de cualquier tema, en español e inglés.
www.worldcat.org - busca dentro de 20.000 bibliotecas globales.
https://link.springer.com - acceso a más de 10 millones de documentos científicos: libros, artículos,
www.bioline.org.br es una biblioteca de revistas de biociencia publicadas
http://repec.org - Voluntarios de 102 países recogieron casi 4 millones de publicaciones
www.science.gov es un buscador del gobierno de los Estados Unidos para más de 2200 sitios científicos.
www.pdfdrive.com es el sitio web más grande para descargar libros en PDF gratis. Reclama más de 225 millones de títulos.
www.base-search.net es uno de los motores de investigación más potentes para textos de investigación académicos. Más de 100 millones de artículos científicos 70% gratis.
Tomado de: Yves Demoulin

#include<iostream>
using namespace std;
int power(int n,int m){
    if(m==0){
        return 1;
    }
    if(m==1){
        return n;
    }
    return n*power(n,m-1);
}
int main(){
    int n,m;
    cin>>n>>m;
    cout<<power(n,m);
}

#include<iostream>
using namespace std;
int fact(int n){
    if(n==0){
        return 1;
    }
    if(n==1){
        return 1;
    }
    return n*fact(n-1);
}
int main(){
    int n;
    cin>>n;
    cout<<fact(n);
}

  override func viewDidLoad() {
        super.viewDidLoad()
    
        let layout = UICollectionViewFlowLayout()
        layout.scrollDirection = .vertical //.horizontal
        layout.minimumLineSpacing = 0
        layout.minimumInteritemSpacing = 0
        popularServicesCollectionView.setCollectionViewLayout(layout, animated: true)
  }

extension ViewController : UICollectionViewDelegateFlowLayout {
  
func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, insetForSectionAt section: Int) -> UIEdgeInsets {
    return UIEdgeInsets(top: 1.0, left: 1.0, bottom: 1.0, right: 1.0)//here your custom value for spacing
}

func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {
    let lay = collectionViewLayout as! UICollectionViewFlowLayout
    let widthPerItem = collectionView.frame.width / 2 - lay.minimumInteritemSpacing
    
    return CGSize(width:widthPerItem, height:100)
}
}

let sheet = workbook.getWorksheet("Report");
  let summary = workbook.getWorksheet("2022");
  let dataTable = sheet.getTable("Data");
  let range = dataTable.getRange();
  let data = range.getValues();
  let rowCount = range.getRowCount();
  let providerID = 5;
  let first = 6;
  let last = 7;
  let labels = 8;
  let codeLabels = 12;
  let driveTime = 13;
  let time = 1;
 
  //adds tables
  let summaryTable = sheet.addTable("Q2:V2", true);
  summaryTable.getHeaderRowRange().setValues([["Label", "ID", "Name", "Billable", "Non-Billable", "Drive Time"]]);
  summaryTable.setPredefinedTableStyle("TableStyleLight1");
  summaryTable.setShowBandedRows(false);
  summaryTable.setShowFilterButton(true);
  summaryTable.getRange().getFormat().autofitColumns();
  let summaryTable2 = sheet.addTable("X2:AA2", true);
  summaryTable2.getHeaderRowRange().setValues([["Location", "Billable", "Non-Billable", "Drive Time"]]);
  summaryTable2.setPredefinedTableStyle("TableStyleLight2");
  summaryTable2.setShowBandedRows(true);
  summaryTable2.setShowFilterButton(false);
  summaryTable2.getRange().getFormat().autofitColumns();
  summaryTable.setName("SummaryTable");
  summaryTable2.setName("SummaryTable2");

  let issuesTable = sheet.addTable("X7", true);
  issuesTable.getHeaderRowRange().setValues([["Issues"]]);
  issuesTable.setPredefinedTableStyle("TableStyleLight3");
  issuesTable.setName("Issues");
  
let id=data[1][providerID];
let name = data[1][last];
let billableSum=0;
let nonBillableSum=0;
let label = "none";
let driveSum = 0;

//This adds the totals for full time and PR productivity people

for (let i = 1; i < rowCount; i++) {
  if(id===data[i][providerID]){
    if (data[i][codeLabels].toLowerCase().includes("productivity")) {
      //This totals the hours for the full time people and labels them
      if (data[i][labels].toLowerCase().includes("full time")) {
        label = "full time";
        driveSum += (data[i][driveTime])/60;
        if (data[i][codeLabels].toLowerCase().includes(",billable ,")) {
          billableSum += data[i][time];
        }
        if (data[i][codeLabels].toLowerCase().includes(",non")) {
          nonBillableSum += data[i][time];
        }
        //This totals the hours for the PR people and labels them
      } else if (data[i][labels].toLowerCase().includes("pr exclusion")) {
        label = "PR";
        driveSum += (data[i][driveTime]) / 60;
        if (data[i][codeLabels].toLowerCase().includes(",billable ,")) {
          billableSum += data[i][time];
        }
        if (data[i][codeLabels].toLowerCase().includes(",non")) {
          nonBillableSum += data[i][time];
        }
      }
    } 
  } else {
    //This adds everyone to the summary table
    if(label!="none"){
      summaryTable.addRow(null, [label, id, name, billableSum, nonBillableSum, driveSum]);
    }
    billableSum = 0;
    nonBillableSum = 0;
    driveSum = 0;
    id = data[i][providerID];
    name = data[i][last]
    label = "none"
    i--;
  }
}

let chicagoBill = 0;
let chicagoNon = 0;
let normalBill = 0;
let normalNon = 0;
let peoriaBill = 0;
let peoriaNon = 0;
let chicagoDrive = 0;
let peoriaDrive=0;
let normalDrive = 0;

//This totals the different regions 
for (let i =1; i<rowCount;i++){
  if (!data[i][labels].toLowerCase().includes("pr exclusion")) {
    if (data[i][codeLabels].toLowerCase().includes("productivity")) {
      //Chicagoland
      if (data[i][labels].toLowerCase().includes("chicagoland behavior")){
        chicagoDrive += (data[i][driveTime])/60
        if (data[i][codeLabels].toLowerCase().includes(",billable ,")) {
          chicagoBill += data[i][time];
        }
        if (data[i][codeLabels].toLowerCase().includes(",non")) {
          chicagoNon += data[i][time];
        }
      }
      //Normal
      if (data[i][labels].toLowerCase().includes("normal behavior")) {
        normalDrive += (data[i][driveTime]) / 60
        if (data[i][codeLabels].toLowerCase().includes(",billable ,")) {
          normalBill += data[i][time];
        }
        if (data[i][codeLabels].toLowerCase().includes(",non")) {
          normalNon += data[i][time];
        }
      }
      //Peoria
      if (data[i][labels].toLowerCase().includes("peoria behavior")) {
        peoriaDrive += (data[i][driveTime]) / 60
        if (data[i][codeLabels].toLowerCase().includes(",billable ,")) {
          peoriaBill += data[i][time];
        }
        if (data[i][codeLabels].toLowerCase().includes(",non")) {
          peoriaNon += data[i][time];
          
        }
      }
    }
  }
}
summaryTable2.addRows(null,[
  ["Chicago BT",chicagoBill,chicagoNon,chicagoDrive],
  ["Normal BTs",normalBill,normalNon,normalDrive],
  ["Peoria BTs",peoriaBill,peoriaNon,peoriaDrive]]);
summaryTable.getSort().apply([{key:0, ascending: true}]);
summaryTable.getRange().getFormat().autofitColumns();
summaryTable2.getRange().getFormat().autofitColumns();

}

let sheet = workbook.getWorksheet("Report");
  let summary = workbook.getWorksheet("2022");
  let rangeSummary = summary.getUsedRange();
  let rangeSummaryValues = rangeSummary.getValues();
  let colCount = rangeSummary.getColumnCount();
  let rowCount = rangeSummary.getRowCount();
  let issuesTable = sheet.getTable("Issues");
  let summaryTable = sheet.getTable("SummaryTable");
  let summaryTableRange = summaryTable.getRange();
  let summaryTableRows = summaryTableRange.getRowCount();
  let summaryTableValues = summaryTableRange.getValues();
  let summaryTable2 = sheet.getTable("SummaryTable2");
  let summaryTable2Range = summaryTable2.getRange();
  let summaryTable2Rows = summaryTable2Range.getRowCount();
  let summaryTable2Values = summaryTable2Range.getValues();
  let dateStartTemp = sheet.getCell(1,0).getValue();
  let dateCalculator = (dateStartTemp - 2)%7;
  let dateStart = dateStartTemp - dateCalculator;
  let findRow = rangeSummary.getRow(0);
  let findRowVal = findRow.getValues();
  let startCell = -1;
  for(let i=1; i<colCount; i++){
    if(findRowVal[0][i]===dateStart){
      startCell = i;
    }
  }
if(startCell === -1){
  console.log("could not find date!")
}
//searches the report for each name in the data table
let success = false;
for(let i=1;i<summaryTableRows;i++){
    for (let j=3;j<rowCount;j++){
      if (rangeSummaryValues[j][0]==="Active"&& summaryTableValues[i][1]===rangeSummaryValues[j][4]){
        rangeSummary.getCell(j, startCell + 1).setValue(summaryTableValues[i][2]);
        rangeSummary.getCell(j, startCell + 2).setValue(summaryTableValues[i][3]);
        rangeSummary.getCell(j, startCell + 3).setValue(summaryTableValues[i][4]);
        success =true;
        break;
      }
      
    }
    //This Reports any one who wasn't in the big report
    if (!success) {
     issuesTable.addRow(null,[summaryTableValues[i][1] + " was not found in report"]);
      summaryTableRange.getRow(i).getFormat().getFill().setColor("FFFF00")

    }
    success = false;
 }
//fills in the bt totals
for (let i = 1; i < summaryTable2Rows; i++) {
  for (let j = 3; j < rowCount; j++) {
    if (summaryTable2Values[i][0] === rangeSummaryValues[j][4]) {
      rangeSummary.getCell(j, startCell + 1).setValue(summaryTable2Values[i][1]);
      rangeSummary.getCell(j, startCell + 2).setValue(summaryTable2Values[i][2]);
      rangeSummary.getCell(j, startCell + 3).setValue(summaryTable2Values[i][3]);
        break;
    }
  }
}

//starting date
let dateStartTemp = sheet.getCell(1,0).getValue();
//how many days after Monday?  
let dateCalculator = (dateStartTemp - 2)%7;
//Date of the Monday of that week
let dateStart = dateStartTemp - dateCalculator;
//The row I want to search  
let findRow = rangeSummary.getRow(0);
  let findRowVal = findRow.getValues();
  let startCell = -1;
  for(let i=1; i<colCount; i++){
    if(findRowVal[0][i]===dateStart){
      startCell = i;
    }
  }
if(startCell === -1){
  console.log("could not find date!")
}

It is an error about react-scripts file missing in your node_modules/ directory at the time of installation.

Check your react-script dependency is avaliable or not in package.json.

If not available then add it manually via:


npm install react-scripts --save