Understanding Bitcoin Core chain catalog: Why reindexing may be necessary

While working with Bitcoin, maintaining a synchronized copy of blockchain can be crucial for safety and integrity. However, one of the aspects that often grabs users is how to deal with problems such as the reindyt of the Chainstate catalog in Bitcoin Core (BTC Core). In this article, we will delve into why reindexing may be necessary and examine the scenarios in which Reindex is good, even if previous attempts are fine.

What is a chain?

The Chainstate catalog is a key element of the Bitcoin core. He stores all the blocks that were extracted by the network, along with the corresponding transactions and other metadata. This information is used to confirm blockchain and ensure its integrity. The Chainstate catalog serves as a single source of truth for the entire blockchain.

why reindexing may be necessary

The Bitcoin core has an internal mechanism called “reindexing”, which periodically synchronizes the Chainstate catalog with the latest blocks. This process is necessary to maintain the integrity and network security. However, this is not always possible or necessary for effective Reindex every time.

Here are some reasons why Bitcoin Core may require Reindex:

1.

• Pruning blocks : After shortening the long block chain, you can lose older blocks, affecting the accuracy of the chain catalog.

• Network instability : In the case of overloading of the network or knot failure, it may take some time before the reindexing process is catching up with the latest changes.

• Old Dialtiss : If the old index catalog has been migrated to a new machine and has not been updated for a long time, the chainstate catalog may become outdated and require reindexing.

Scenario: Successful migration, but reindexing still requires

You are right that some people successfully migrated their old index catalogs to the new machine without having to bind again. This is due to the fact that they probably took steps to make sure that the new directory of the index is current, such as:

1.

2.

3.

Although the migration of the old directory of index may seem a simple process, it may be associated with additional steps in ensuring the success of the reindexification process. If you experience problems or encounter problems while attempting to migrate or re -Zindex Bitcoin Core, it is necessary to read the official documentation and social forums to obtain tips.

Application

Re -indexing of the chain catalog may sometimes be necessary due to changes in the structure of the blocks, pruning, network instability or old index catalogs that are not fully valid. While the migration of the old directory of the index may seem a simpler process, making sure it is properly updated before indexing, is crucial for maintaining the integrity and safety of Bitcoin Core configuration.

Understanding Ethereum’s Coinbase Maturity: Why 100 Not 50?

As a blockchain enthusiast, you’re likely familiar with the concept of Coinbase maturity, which refers to the time between a block being mined and its inclusion in the blockchain. The traditional definition of Coinbase maturity is 10 minutes, meaning that blocks are added to the chain every minute. However, some users have questioned this assumption, citing concerns about orphaned blocks.

One such question comes from the Ethereum community, where it has been argued that Coinbase’s maturity rate should be set at 100, not 50. In an attempt to address this discrepancy, we’ll delve into the reasoning behind Coinbase’s current definition and explore possible explanations for why it stands at 100 minutes.

Why 100 minutes?

Coinbase’s default block time was initially set at 10 minutes due to factors such as:

• Network congestion

  : The Ethereum network is designed to process transactions quickly, but it can become congested when there are many requests coming in simultaneously.

• Data storage and processing: Each block requires significant computational power to validate the transactions within it and store the blockchain data.

• Consensus algorithm: The Proof of Work consensus mechanism used by Ethereum, which relies on high-performance computing to secure the network.

However, as the network grew and more users began to use Coinbase, there was a need for a more balanced solution that could accommodate different usage patterns. By increasing the block time to 100 minutes, Coinbase aimed to:

• Reduce congestion: By spreading out the processing of blocks over a longer period, the network became less congested.

• Improve scalability: A 100-minute block time allowed for more efficient use of computing resources and reduced the likelihood of bottlenecks in the network.

Orphaned blocks: The elephant in the room?

The concept of orphaned blocks is indeed a significant concern, particularly if Coinbase’s default block time of 10 minutes becomes too short. Orphaned blocks refer to unconfirmed or partially confirmed transactions that have been waiting for a certain period before being added to the blockchain.

When Coinbase increases its block time to 100 minutes, it can help reduce orphaned blocks in several ways:

• Increased confirmation rate

  : With more time between block creation and inclusion in the chain, the likelihood of unconfirmed or partially confirmed transactions being reconfirmed decreases.

• Improved network stability: A longer block time reduces the likelihood of network congestion and bottlenecks, which can help prevent orphaned blocks from accumulating.

Conclusion

While Coinbase’s default block time of 10 minutes may seem arbitrary at first glance, it has been optimized over time to balance competing demands for scalability, security, and performance. The increased block time of 100 minutes is a deliberate design choice that aims to:

• Reduce congestion: By spreading out processing times, the network becomes less congested.

• Improve scalability: A longer block time allows for more efficient use of computing resources.

As for why Coinbase hasn’t reduced its block time further or adopted 50 minutes as a default value, it’s likely due to a combination of factors:

• Network performance: Increasing the block time too much would require significant updates to the network infrastructure and potentially impact user experience.

• Community feedback: The community has largely accepted Coinbase’s current block time and expects the network to continue operating within its established parameters.

In summary, Coinbase’s default block time of 100 minutes is a deliberate design choice aimed at balancing competing demands for scalability, security, and performance.

MONERO YOUR NEEDS

Problems of the Ethereum and Binance API: a solution for the creation of limit orders

As an enthusiastic and cryptocurrency developer, you are not alone to face the frustration of finding the Lot_Size error when creating orders limit in the Binance API. In this article, we will deepen the reasons behind this problem and provide a solution to solve it.

The problem: Lot_Size error

The Lot_Size error (1013) is an internal error that occurs during the execution of an order of limit in the Binance API. The exact cause of this error can be difficult to determine, but the common guilty includes:

• Incorrect or missing necessary parameters

• Inappropriate or missing market data

• Insufficient balance in your account

The problem: min quantity

A potential reason for the Lot_Size error is a problem with the Min Amount parameter. When establishing the minimum amount of a limit order, it is possible that you exceed the margin available in your account.

To solve this, immerse in some examples of Python code and explore possible solutions.

Example code: Creation of Binance API limit

`Python

Import requests

Replace with its Binance API credentials and end point url

API_URL = "

Defines the consultation parameters for the creation of the limit order

Query_params = {

"Symbol": "ethusd",

specify the pair of assets

"Side": "limit",

specify if it is a purchase or sale request

"Type": "order",

order type (in this case, limit)

"Address": "Buy",

Commerce address (buy/sell)

"Quantity": 0.1,

amount of order (in decimal format, for example, 100)

"Timeinforce": "Well until canceled"

time in force for the order

}

Configure authentication and headers

headers = {

"Type of content": "application/json",

"X-MBX-Apikey": "Your_api_Key"

}

Execute the consultation

Answer = request.post (API_url, Json = Query_params, headed = headers)

Check if the answer contains an error message

If "error" in response.json () ::

print ("error:", answer.json () ["error"] ["message"])

others:

Handling the API Successful API

order_id = answer.json () ["data"] ["Orderid"]

print (f "order of limit created: {order_id}")

Solve the error Lot_Size

When examining your code, you can see that establishing the 'min_quantity parameter at 0.1 is probably causing error. You can try to increase this value to guarantee enough margin in your account.

In addition, make sure:

• The balance of your account has enough funds for the transaction.

• The Lotesize (in this case,Lot_size) API returns a successful response without any error.

Additional tips and problem solving

To further solve the problem, consider verifying the following:

• Verify that your Binance API credentials are correct and updated.

• Make sure you are using the Correct Final Point URL for the creation of limit orders (

• Verify if there is any other error or warning in the JSON answer.

If none of these steps solve the problem, provide more details about its configuration and environment, including your Binance API credentials, account information and code fragments. We will be happy to help you more!

Title: Solana: Running Anchor Build Gives Error

Introduction:

Solana, a fast and scalable blockchain platform, relies on various tools and dependencies to function properly. However, as with any software development project, errors can arise from the installation or configuration of these tools. In this article, we’ll delve into a common issue that can occur when running an Anchor build on Solana.

Error Description:

When attempting to run the Anchor build using the anchor command-line tool, users may encounter an error stating “Failed to install platform-tools”. This error is caused by an issue with the installation of necessary tools required for the Anchor build process. Specifically, the error indicates a 404 Not Found response from GitHub when trying to download the platform-tools.

Step-by-Step Solution:

To resolve this issue, follow these steps:

Step 1: Identify the Problem

The first step is to understand why the platform-tools are not being downloaded successfully. Review the error message and inspect the project’s dependencies. In this case, it appears that the cargo_build_sbf command is failing to install the required tools.

Step 2: Check Dependencies

Verify that the necessary dependencies for Anchor are installed on your Solana node. You can check by running the following command:

cargo build --bin anchor

This will attempt to build the anchor binary using Cargo, which should install any required dependencies. If you encounter errors or warnings during this process, take note of them.

Step 3: Update Cargo Build Dependencies

Update your Cargo build dependencies to ensure they are compatible with the latest requirements:

cargo update --path .

This will check for and update any outdated dependencies that may be causing issues.

Step 4: Update Platform-Tools

Update the platform-tools package to ensure you’re using the latest version. Run:

cargo install platform-tools@latest

If the platform-tools package is not available or outdated, consider updating to the latest version using:

cargo update --no-deps platform-tools@latest

Step 5: Try Running Anchor Again

After updating your dependencies and platform-tools, try running the anchor command again. If you’re still experiencing issues, ensure that:

• You have a stable internet connection.

• The Solana node is fully up-to-date with the latest configuration files.

Conclusion:

Running an Anchor build on Solana can be affected by various issues related to dependencies and platform-tools installation. By following these steps, you should be able to resolve the error and successfully run your Anchor project. If you continue experiencing difficulties or encounter specific problems, consider reaching out to the Solana community or the official GitHub repository for support.

Metamask Error: Verifying Signed Data with Ether.js Sigtypeddata

When using the ethers.js library to sign and and code data as a signed typed dates, solidity’s metamask may encounter an error that prevents it from verifying the signed data. In this article, We’ll Explore the Issue and Provide a Possible Solution.

The issue:

The error typically occurs when attempting to verify the signed data using metamask’s verify function on theSigtypeddates Property Returned by Ethers.js. The Problem Lies in How Solidity’s Sigtypeddates function interacts with the ethers.js library and theverify method.

Sign TypeDates Functionality

When you call Sigtypeddates on your data, it creates a signature of the input data using the signer’s private key. However, when verifying this signed data in Metamask Using Verify, the Library Expects to Receive the Original Unaltered Input Data As An Argument.

ethers.js sign type dates

The Signtypeddata function is designed to create and verify a signature of the input data without altering it. To use Sigtypeddates with ethers.js, you need to create a signed version of your input data that can be verified by the library.

For Example:

`Javascript

Const Domain = {

Name: ‘OG-NFT’,

Version: ‘1’

};

Constations = {

// …

};

// Create a Signed Version of the Data Using Ethers.js Sigtypeddata

Constatature = Await ethers.sigtypeddata (

{

type,

Value: {

OG_NFT: {…} // Replace With Your Actual Input Data

}

},

‘0x …’ // Replace with your private key

);

// create a signed type dates from the signed data

Const Sigtypeddata = Ethers.Signer.Sigtypeddata (Signature, Domain);

`

In This Example, We First Create A Signature Object Using Ethers.js’sSigtypeddata "function. We then use this signature to create a typed data object, which is used for verification.

Metamask Verification Issue

Now that you have the signed type dates object in place, you can attempt to verify it in metamask. However, As Mentioned Earlier, Metamask'sVerifyfunction expects the original unaltered input data as an argument.

To fix this issue, you need to create a new typed data object with the same property and value as your original input data. In other words, you need to recreation the original input data using ethers.js.

Javascript

// Create a new Typed Data Object From the Signed Type Dates

const verification = ethers.signer.verifyyTyped (

Sigtyped dates,

Domain,

{Type: ‘Unverify’} // Replace with Your Private Key

);

// Verify the Typed Data Using Metamask’s Verify Function

await metamask.verify (verification);

`

In this example, we create a new verification 'object by calling ethers.js's verifyTypedfunction on the signed typing dates. We then pass the original input data (domain) and a verification key (which can be obtained using ethers.js).

By recreation the original input data using ethers.js, you should now be able to verify the signed data in metamask.

Conclusion

In this article, we've explored the issue of verifying signed typed dates using metamask with ethers.js. By understanding How Solidity'sSigtypeddates` function interacts with ethers.js and creating a new typed data object from the signed data, you should be able to resolve the error and verify your signed data in metamask.

ETHEREUM CGMINER FREEZES INTERVALS

Ethereum: Creating A New Ethereum Address in Electrum

For those new to ethereum and electric, understanding how to create a new address is essential for managing your funds. However, the process might like the challenging if you encounter difficulties with it. In this article, we will walk through the steps to create a new etherum address using electrum.

Step 1: Launch Electrum

First, ensure that you have launched electric on your computer and are connected to the ethereum network. If you still unsure about how to launch electric, refer to our previous articles for more information.

Step 2: go to address tab in electric

Once electric is launched, navigate to the addresses tab by clicking on the “Addresses” tab at the top of the Window or Pressing Ctrl + A (Windows/Linux) or CMD + A(Mac).

Step 3: Location The New Address Button

Under the addresses tab, you will see a list of existing addresses. However, there is no button labeled "New Address". This might have confusing at first, but it's likely due to Electrum's Design.

Step 4: Access Console and Create New Address

To create a new address in the console, follow these steps:

• Click on the "console" tab at the top of the window.

• In the console box, typeCreate ()and Press Enter.

• This will initiate a transaction to create a new address.

Step 5: Check Your New Address

After creating a new address using thecreate ()` command in the console, you should be prompted for confirmation. If Electrum is Able To Generate A Unique Address, It should Display Your New Address At The Top Of The Console Tab.

If you are followed these steps and still encounter issues with generating a new etherum address, there might be an underlying problem with your electrum installation or ethereum network connection.

troubleshooting tips

• Ensure that your Electrum Software is up to date.

• Check if there are any conflicts between Electrum and other wallet software.

• Try creating a new address on the main ethereum website: <

By following these steps, you should be able to create a new etherum address in Electrum. If issues persist, consider reaching out to our support team for further assistance.

Conclusion

Creating a new Ethereum address in electrum can seem intimidating at first, but with the right troubleshooting steps and understanding of the process, you should be able to generate a unique address without any complications.

tether cosmos atom risk assessment

Complex world of cryptocurrencies: cryptography, exploration of pools and future settlements

In the ever -evolving scenario of the cryptocurrency trade, investors are constantly looking for new opportunities to maximize their profits. The popular strategy is to use a settlement pool (also known as stop or slip) to manage risks and optimize the return on negotiations. Another approach involves exploiting future markets to speculate cryptocurrency price movements.

In this article, we go deeper into the world of cryptocurrency negotiations, exploring the concepts of encryption, liquidity pools, pool -based strategies and future markets. We examine how to use these various approaches to produce profits, to manage risks and market trends.

What is crypto?

A cryptocurrency or “currency” is a digital device that uses encryption for secure financial transactions. The most well -known cryptocurrencies are Bitcoin (BTC), Ethereum (ETH) and Litecoin (LTC). Cryptocurrencies operate on a decentralized network, allowing users to send, receive, and store value without needed intermediaries such as banks.

What is the municipal pool?

The municipal pool, also known as Stop or sliding pool, is an algorithmic negotiation strategy used in the cryptocurrencies. Its main function is the protection of investors from possible losses by automatically buying or selling assets when they reach certain levels of risk.

It works like this:

• The municipal pool creates a position to minimize losses.

2.

• When a device reaches a predetermined level of slippage (or loss), the pelvic bodies or automatically sell the device to limit potential damage.

Liquidity Pools

Municipal pools are often used in high -frequency negotiations, where there are rapid price movements and sudden changes in market conditions. These pools can help alleviate the risk by providing a protective pillow against high losses.

Some examples of liquidity pools are as follows:

* Binance Liquid Market : Binance -run municipal pool, the largest cryptocurrency exchange that allows users to purchase or sell devices to minimize losses.

Kraken Liquidity Basin : Another example of the settlement pool offered by the popular cryptocurrency exchange.

Pool -based strategies

Pool -based strategies include exploiting various cryptocurrencies and markets to maximize investment returns. Here are some examples:

1
Macro-Pooling : The Macro-Pool Strategy includes collecting funds with other investors to speculate on market trends and price movements.

• Neutral market pools : Neutral market pools use a combination of assets such as shares and cryptocurrencies to generate paybacks, exploring the benefits of diversification.

3.

Future markets

Future markets offer investors opportunities to speculate on cryptocurrency price movements without taking the asset class directly. It works like this:

1.

• Stock Exchange and Platforms : Future markets operate in exchange programs such as CME (Chicago Mercantile Exchange) or Intercontinental (ICE) or patented platforms such as Robinhood.

Conclusion

In summary, the cryptocurrency trade includes exploiting various strategies for managing risks, maximizing profits and keeping market trends.

METAMASK FAILING TEST SERVICES

Here you will find a high quality, read and well -format article based on your request:

Solana Watching Webocets using Solana

As an enthusiastic seller and enthusiastic decentralized financial platforms (DEFI), Raydium activity can be valuable assets for retailers. One way to achieve this is to use the Logsubscribe method, which returns direct access to Ray_logs and provides real -time insights on token operations.

What are the protocols?

Defi protocols are related to historical data collected from blockchain networks. Solana these protocols are saved in the database and can be reached using API or Weboxes. The Logsubscript method enables direct updates to this data to be an ideal choice for chips.

Websockets and Logssubscribe Method

Websopits offer a two -way communication channel between the customer (in this case its application) and the server. In this way, real -time updates can be sent from the server to the customer without requiring surveys or other time -consuming mechanisms.

The Logsubskribe method is a specific Solana API, with which customers can subscribe to certain token protocols. If this method results in a token protocol, the object containing the protocol data in JSON format is returned. Decoded JSON -TTTTS has various fields related to registered operations such as: b.: B.: B.

• Time Tag: The time the transaction took place

• Txid: clear identification of surgery

• "Sum": The sum of the chips involved in the operation

• "Fee": for an operation processing fee

JSON PAYOAD

Example **

Here is a decoded example of a JSON shelter, which is the Ray_log structure: demonstrates:

Json

{

Time Temple: 1643723900,

TXID: 0x1234567890abcdef,

“Review”: 10.0,

“Fee”: 1,0,

// … other fields …

}

`

Use Logsubscribe Raydium

To achieve direct protocols using the Logsubscribe method, you need to create a living room connection with Solana SDK and subscribe to the interests of Token (such as your goal access key). Receiving log data will be processed and available in your program.

Here is a simplified example of how to run Raydium method Logsubscribe:

`Javascript

Import {web3provider} from ‘@solana/web3.js’;

Import {logsubscribe} from ‘./api’;

// Create a new copy of the Web3 provider

Const provider = new web3provider ();

// Set Solana SDK

CONST SDK = New Web3 (provider);

// Subscribe to Target token protocols using the Logsubscribe method

Asynchicitic function of Getlogs () {

CONST [TXID, LOGIDEX] = Watte Sdk.Getlogids (

[the process.env.solana_token_id],

[‘Last’, ‘1’]

);

IF (TXID && Loginex) {

the test {

// Read magazines from Blockchain

CONST LOGS = Waiting Provider.GetLS ({{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{)

LOGID: TXID,

Numard: Logindex,

Accounts: [

the process.env.solana_Token_id,

// Other accounts involved in the operation …

] ‘

});

// Treat and return the decrypted JSON protection load

return logs.map ((log) => {

const {txid, quantity} = log.data;

return {

Time Seal: New Date (log

txid,

The crowd,

};

});

} Catch (error) {

console.error (error);

}

} differently {

console.log (‘no protocols’);

}

}

// Call the Getlogs feature to access and process log data

Getlogs (). Then ((magazines) => console.log (magazines));

`

This example shows how to create a site connection, subscribe to the target access key protocols using the Logsubscribe method, and decipher the JSON shelter to extract the operations.

Ethereum Bech32 Addresses

Reduting Diffiolty or Estenineum Testnets: Simplification of the process

*

As a tester e sterneum, you ‘Onne Commonning is a genet block of genet enough to confirm the workouts, which Cantal minutes a Duke Macbonook until the time is in charge of problems.

In this article, we will explore ways to reduce the difficulty tests on Eyeneum Eyetts, doing FFICIS FFICETT processes.

Current limits **

We have sank ourselves in pontential solutions, quickly come up with block generation: MacBocks:

• The

• Thirs delaying Betribovedid to Blockchain values, which involves checking on the Blockchain Data.

Simplification of processes: Work solutions and work

**

Borned, there are several ways to reduce the diffility of the generation of tests on eteneum:

• * Hh neuthodorrt netsite, if possible, you can try to look at Nettlings Ethrineum to use the Aster configuration, such third -party plugin.

• Le Yis is not an option for everyone, modernization, modernization of USRTRISISSIASSSSSIASIARS (GPPE) CINSINIFIC TIMAWES.

• H Astnet with a faster gene block **: Somemetestes are designated to have short overloads SHORNES SHORNES OF YOU TERNES OF JOURS. You can Chheck Checific, a specific test has a Fastnes block near the Great Online Law for “Forever] Genesis Blocke”.

• * Wait a more recent teste*: newer tests from post blocks or OPISE CANCELLING REDUCE IN TIME.

• H of script or custom tool **: There are several Avimable Scriptures and tools, Sucks

Practic for optimal testing *

While the reduction of dipher is essential, it is as imposed on minis practices when Termum:

• Always use a fresh blockchain (eg from the Lastnet test) Bephating Starstin.

• Configure multiple twin accounts and start new to avoid conflicts or emissions through the mayor of the primary account.

• Softwarist races and out-DADTE outbreaks to ensure optimitism or improvement.

conclusion

The difference or ethms of discount requires a communication to adjust the placement, the update wars and the express conflicts. By exploring the soles and the best practices, you can process stones and you can do more mirectial. Don’t forget to always print new features or configurahs campaign campsite, as a cultivation of the Imroper opmitization to unaxisous boards.

Stay up to date with the tests developments and the optate techniques in Laststeum, by renown the reputations and the participation in the web or the conference OP. Happy testing!

ethereum value updated

The World of Cryptocurrrenreny Trading Has urondergone Sindergon changes Change in the Years. Assets and Tokenized Assets Has Oportus for Traders to By, Selll, and Trade Cryptoctories With the Traditional for Traditional Explads. Tyy Technologies of Are driving Third Tishsim to Akenzed Apis and Mnemocrases.

Tocenized Appis: A New Standard for Trading

Tokenzenized Aposs to the Prophess of Creating Cresm Appis (Applicated Programs interfaces) for Specific (Applicicals) for Specific (Applicific applicifics orrvices, Suk Asptrong Platographerms. These Are Allow Traders to Interact With Difrerent Parts of a Systeam, Such Asment Proysinging, order Management, and Market data Feds.

The Bepheds of Tokenized Apis A numerus:

.

* Security: Tokenzed Aposence Advive Encryption Methods to Protective Sensiim information, Such As apia keys and Credensias.

SCCCABIity

: By Leveraging Multiping Multiping Multiped, Traders Can Increase Their Trading Capefaciocting performale or securority.

for Elamle, a Cyptocurrrender tradrm lintorm Uses Uses Tokes to the Its Paysing and Order mannagements systems. Its Allows Users to Access a Accesss acress in Features, Including Real-Tiy Market dads, Risk Man Management Tools, and Adveding Algorithms.

Mnemonic Phrases: A Securor and Convenistant wy to manage Cryptocurration *

MNinemonication Is Essental for Security Reasons, Aswall Allons to Reconing Ther Fins in the Case Forget Their Password.

The Befits of Using MNIMICAN PHASes are:

* security

: Mneemic Prases rases Additional Layer of Seking by Making It Diffiolt for Othsis to Othsys Funds.

* Convenence*: With a mnemonic Phrase, You Can Manages Multiple Wallets and Exchanges eth ethy.

* ordanzanzation of Befitts*: Mnemonics Kelps track of Passwrds and or or or or or or or or or or or or or or or or or or to Other Sensimive in a-Aganzed Manner.

For Instance, the Popular Cryptocurration Exacrose Uses Uses mnemoses to percounts. This Ensures That Funds air Protected and Accesiterable Only Throgh the Unnique Phrase.

The Role of Tokenzedis and mnemovien phrases in Cryptoclery Trading

Together, Tokenzenized Appis and mnemoses Play in Revolutioning the World of Cryptoctor Trading. By

cusus-tonytas to autoãil Market dads, risk management Tools, and Other featis.

* ing Maximimme Profitarity: Lezage Adveding Algorithms and Real-Tiy Marketsis to Increaes trading trading trading tradingry.

In The Cyptoctorrationment Industry. Cryptoctorrenciies.

tsps for Imlementing Tokenzed Appis and mnemonic Phrases **

1.

2.

.