Rail Weight Calculator

Rail Weight Calculator: Calculate Track Load Capacity body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background-color: #f8f9fa; color: #333; line-height: 1.6; margin: 0; padding: 0; display: flex; flex-direction: column; align-items: center; } .container { width: 100%; max-width: 1000px; margin: 20px auto; padding: 20px; background-color: #ffffff; box-shadow: 0 2px 10px rgba(0, 0, 0, 0.05); border-radius: 8px; display: flex; flex-direction: column; align-items: center; } h1, h2, h3 { color: #004a99; text-align: center; } h1 { margin-bottom: 10px; } .loan-calc-container { width: 100%; max-width: 600px; padding: 25px; border: 1px solid #ddd; border-radius: 8px; background-color: #ffffff; margin-bottom: 30px; display: flex; flex-direction: column; align-items: center; } .input-group { width: 100%; margin-bottom: 15px; display: flex; flex-direction: column; align-items: flex-start; } .input-group label { display: block; margin-bottom: 8px; font-weight: 500; color: #555; } .input-group input[type="number"], .input-group select { width: calc(100% – 20px); padding: 10px; border: 1px solid #ccc; border-radius: 4px; font-size: 1rem; box-sizing: border-box; transition: border-color 0.3s ease; } .input-group input[type="number"]:focus, .input-group select:focus { border-color: #004a99; outline: none; } .input-group small { display: block; margin-top: 5px; font-size: 0.85rem; color: #6c757d; } .error-message { color: #dc3545; font-size: 0.85rem; margin-top: 5px; display: none; /* Hidden by default */ } .button-group { width: 100%; display: flex; justify-content: space-between; margin-top: 20px; } button { padding: 10px 20px; border: none; border-radius: 5px; cursor: pointer; font-size: 1rem; font-weight: 500; transition: background-color 0.3s ease, transform 0.2s ease; } .primary-button { background-color: #004a99; color: white; } .primary-button:hover { background-color: #003366; transform: translateY(-2px); } .secondary-button { background-color: #6c757d; color: white; } .secondary-button:hover { background-color: #5a6268; transform: translateY(-2px); } #result-display { width: 100%; max-width: 600px; margin-top: 30px; padding: 20px; background-color: #e9ecef; border-radius: 8px; text-align: center; border: 1px dashed #004a99; } #result-display h3 { margin-top: 0; color: #004a99; } #main-result { font-size: 2.5rem; font-weight: bold; color: #28a745; display: block; margin-bottom: 10px; } .intermediate-results { display: flex; flex-wrap: wrap; justify-content: center; gap: 15px; margin-top: 15px; font-size: 0.95rem; } .intermediate-results div { background-color: #ffffff; padding: 8px 12px; border-radius: 5px; border: 1px solid #ddd; } .intermediate-results span { font-weight: bold; color: #004a99; } .formula-explanation { margin-top: 20px; font-size: 0.9rem; color: #555; text-align: left; padding: 10px; background-color: #f0f0f0; border-radius: 4px; } #copy-results-button { background-color: #ffc107; color: #333; margin-top: 15px; } #copy-results-button:hover { background-color: #e0a800; } table { width: 100%; border-collapse: collapse; margin-top: 20px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); } th, td { padding: 10px 12px; text-align: left; border-bottom: 1px solid #ddd; } thead { background-color: #004a99; color: white; } th { font-weight: 600; } tbody tr:nth-child(even) { background-color: #f2f2f2; } caption { caption-side: top; font-weight: bold; margin-bottom: 10px; font-size: 1.1rem; color: #004a99; text-align: left; } canvas { margin-top: 20px; border: 1px solid #ccc; background-color: #fff; border-radius: 4px; } .chart-container { width: 100%; max-width: 600px; margin: 20px auto; padding: 15px; background-color: #ffffff; border-radius: 8px; box-shadow: 0 1px 5px rgba(0,0,0,0.1); } .chart-container h3 { margin-top: 0; margin-bottom: 15px; } .article-section { width: 100%; margin-bottom: 40px; padding: 20px; background-color: #ffffff; border-radius: 8px; box-shadow: 0 2px 10px rgba(0, 0, 0, 0.05); } .article-section h2 { text-align: left; margin-bottom: 15px; border-bottom: 2px solid #004a99; padding-bottom: 5px; } .article-section h3 { text-align: left; margin-top: 20px; margin-bottom: 10px; color: #0056b3; } .article-section p { margin-bottom: 15px; } .article-section ul, .article-section ol { margin-left: 20px; margin-bottom: 15px; } .article-section li { margin-bottom: 8px; } .faq-item { margin-bottom: 15px; padding: 10px; background-color: #f0f8ff; border-left: 3px solid #004a99; border-radius: 4px; } .faq-item strong { color: #004a99; display: block; margin-bottom: 5px; } .internal-links-section ul { list-style: none; padding: 0; } .internal-links-section li { margin-bottom: 10px; } .internal-links-section a { color: #004a99; text-decoration: none; font-weight: bold; } .internal-links-section a:hover { text-decoration: underline; } .internal-links-section span { font-size: 0.9rem; color: #555; display: block; margin-top: 3px; } .highlight { background-color: #fff3cd; padding: 2px 5px; border-radius: 3px; } @media (max-width: 768px) { .container { margin: 10px; padding: 15px; } button { padding: 8px 15px; font-size: 0.95rem; } .button-group { flex-direction: column; gap: 10px; } #result-display { padding: 15px; } #main-result { font-size: 2rem; } .intermediate-results div { padding: 6px 10px; font-size: 0.9rem; } }

Rail Weight Calculator

Determine the precise weight of railway tracks for engineering and load planning.

Calculate Rail Weight

Enter the length of the rail in meters.
Enter the weight of the rail in kilograms per meter (e.g., 55 kg/m, 60 kg/m).
Typically 2 rails for a standard track. Enter the total number of rails being considered.

Results

Total Weight (kg):
Total Weight (tonnes):
Weight per Meter:
Formula Used:

Total Rail Weight = (Rail Length × Weight Per Meter × Number of Rails)

Weight in Tonnes = Total Rail Weight / 1000

Weight Distribution Across Rails

Weight comparison of individual rails and total track segment.
Rail Specification Summary
Metric Value Unit
Rail Length Meters
Weight Per Meter kg/m
Number of Rails
Total Weight (kg) kg
Total Weight (tonnes) tonnes

What is Rail Weight?

Rail weight, often expressed in kilograms per meter (kg/m) or pounds per yard (lb/yd), is a fundamental specification for railway tracks. It quantifies the mass of a linear segment of the rail. This weight is directly correlated with the rail's profile (its cross-sectional shape and dimensions) and the type of steel used in its manufacture. Higher rail weights generally indicate stronger, more robust rails designed to withstand greater loads and stresses, making them suitable for heavier freight traffic, high-speed passenger lines, or extreme environmental conditions. Understanding rail weight is crucial for engineers, construction managers, and railway operators when planning infrastructure projects, assessing track capacity, and ensuring safety and efficiency.

Who should use it: Railway engineers, track maintenance crews, civil engineers, project managers for railway construction, load planners for railway transport, and researchers in transportation engineering commonly use rail weight data. It's also relevant for anyone involved in the procurement or specification of railway materials.

Common misconceptions: A common misconception is that rail weight solely dictates a rail's strength. While it's a strong indicator, the rail's profile design (e.g., head, web, and foot dimensions), steel quality, and proper installation (including fastening systems and ballast) are equally critical for overall performance and load-bearing capacity. Another misconception is that all rails are the same weight; in reality, rail weights vary significantly based on application, with lighter rails used for industrial sidings and heavier rails for main lines.

Rail Weight Formula and Mathematical Explanation

The calculation of total rail weight for a given track segment is straightforward and relies on three key parameters: the length of the rail, its weight per linear meter, and the number of rails being considered.

The Core Formula

The primary formula to determine the total weight of a rail segment is:

Total Rail Weight (kg) = Rail Length (m) × Weight Per Meter (kg/m) × Number of Rails

To express this weight in metric tonnes, we convert kilograms to tonnes:

Total Rail Weight (tonnes) = Total Rail Weight (kg) / 1000

Variable Explanations

  • Rail Length (L): This is the physical length of a single rail segment, typically measured in meters (m). For example, standard rails might be 25 meters or 36 meters long.
  • Weight Per Meter (WPM): This is a standardized value provided by the rail manufacturer, indicating how much one meter of that specific rail profile weighs. It's usually given in kilograms per meter (kg/m). Common values include 55 kg/m, 60 kg/m, and 70 kg/m.
  • Number of Rails (N): This represents the total count of rails involved in the calculation. For a standard railway track, this is typically 2 (one for each side of the gauge). However, for specific projects or analyses, one might consider a single rail or multiple parallel rails.

Variables Table

Rail Weight Calculation Variables
Variable Meaning Unit Typical Range
Rail Length (L) The linear measurement of a single rail segment. Meters (m) 10 m to 100 m (common: 25 m, 36 m)
Weight Per Meter (WPM) The mass of one meter of the rail profile. Kilograms per meter (kg/m) 40 kg/m to 75 kg/m (common: 55, 60)
Number of Rails (N) The total count of rails being analyzed. Unitless 1 to 4 (common: 2)
Total Rail Weight (TRW) The total mass of all rails considered. Kilograms (kg) Calculated
Total Rail Weight (Tonnes) The total mass in metric tonnes. Tonnes (t) Calculated

Practical Examples (Real-World Use Cases)

Let's illustrate the rail weight calculation with practical scenarios:

Example 1: Standard Mainline Track Segment

A railway company is assessing a section of its main line that uses standard 60 kg/m rails. Each rail is 36 meters long, and they need to calculate the total weight for a 1-kilometer (1000 meters) stretch, which requires two parallel rails.

  • Input Values:
  • Rail Length: 36 meters
  • Weight Per Meter: 60 kg/m
  • Number of Rails: 2

Calculation:

Total Rail Weight (kg) = 36 m × 60 kg/m × 2 = 4320 kg

Total Rail Weight (tonnes) = 4320 kg / 1000 = 4.32 tonnes

Interpretation: This 36-meter segment of track (total length of 72 meters of rail) weighs 4.32 tonnes. This information is vital for calculating the load on the subgrade, determining transport logistics for materials, and estimating the structural requirements for bridges and viaducts supporting this track section.

Example 2: Industrial Siding with Shorter Rails

An industrial facility is installing a new siding track that uses 55 kg/m rails, supplied in shorter 25-meter lengths. The siding is 200 meters long and uses a single track (two rails).

  • Input Values:
  • Rail Length: 25 meters
  • Weight Per Meter: 55 kg/m
  • Number of Rails: 2

Calculation:

First, calculate the weight per meter for the entire siding length:

Total Rail Weight (kg) = 200 m × 55 kg/m × 2 = 22000 kg

Total Rail Weight (tonnes) = 22000 kg / 1000 = 22 tonnes

Interpretation: The 200-meter industrial siding track, using 25-meter rail lengths, has a total rail weight of 22 tonnes. This data helps in planning the foundation requirements for the siding and managing the inventory of rails needed for the project. The use of shorter rails might imply simpler installation or specific site constraints.

How to Use This Rail Weight Calculator

Our Rail Weight Calculator simplifies the process of determining the mass of railway tracks. Follow these steps for accurate results:

Step-by-Step Instructions

  1. Enter Rail Length: Input the length of a single rail segment in meters. Standard lengths are often 25m or 36m, but use the actual length if different.
  2. Enter Weight Per Meter: Input the specific weight classification of the rail profile in kilograms per meter (kg/m). This information is usually found in rail specifications or on manufacturer datasheets (e.g., 55 kg/m, 60 kg/m).
  3. Enter Number of Rails: Specify the total number of rails being considered. For a typical track, this will be '2'. Adjust if you are calculating for a single rail or a more complex configuration.
  4. Calculate: Click the "Calculate Weight" button.

How to Read Results

  • Main Result (Total Weight): The most prominent figure shows the total weight of all rails you've entered data for, displayed in both kilograms (kg) and tonnes (t). This is the primary output for load and inventory purposes.
  • Intermediate Values:
    • Total Weight (kg): The calculated weight in kilograms.
    • Total Weight (tonnes): The calculated weight converted to metric tonnes for easier comprehension of larger quantities.
    • Weight per Meter: Reiteration of the input value, confirming the specific rail profile used.
  • Formula Explanation: A clear breakdown of how the results were computed, reinforcing transparency.
  • Table Summary: A structured table provides all input and output values for quick reference and comparison.
  • Chart: Visualizes the weight contribution of each rail and the total segment, aiding in understanding distribution.

Decision-Making Guidance

The calculated rail weight is fundamental for several engineering decisions:

  • Structural Integrity: Knowing the total weight helps engineers design appropriate foundations, ballast layers, and supporting structures (like bridges) to handle the load.
  • Material Procurement: Accurate weight calculations are essential for ordering the correct quantity of rails and estimating project costs.
  • Logistics and Transport: The total weight dictates the type of heavy machinery and transport vehicles required for moving and installing the rails.
  • Track Classification: Heavier rails typically support higher axle loads and speeds, influencing the classification of the track (e.g., mainline, freight, light rail).

Key Factors That Affect Rail Weight Results

While our calculator provides a precise mathematical output based on your inputs, several real-world factors influence the context and application of rail weight:

  1. Rail Profile Design: The specific cross-sectional shape (head, web, foot dimensions) is the primary determinant of a rail's weight per meter. Different profiles are designed for varying load capacities, speeds, and track geometries. For instance, heavier rails often have a larger head for wear resistance and a stronger web and foot to distribute load.
  2. Steel Quality and Grade: While not directly changing the physical dimensions (and thus weight per meter), the type and grade of steel used impact the rail's strength, durability, and resistance to wear and fatigue. Higher-strength steels might allow for slightly different profiles that could alter weight, or they are used in conjunction with standard heavy profiles to enhance performance.
  3. Track Gauge: Although gauge (the distance between the rails) doesn't alter the weight of individual rails, it influences the overall track structure and the number of sleepers (ties) and fasteners required, which are part of the track system's total weight but not the rail weight itself.
  4. Standardization vs. Customization: Railway standards (like UIC, AREMA) define specific rail profiles and their corresponding weights. While most projects use standardized rails, custom profiles can be designed for unique applications, potentially altering the standard weight-per-meter values.
  5. Ballast and Formation: The weight of the rails is only one component of the total track structure. The ballast (crushed stone), sub-ballast, and formation (prepared ground) beneath the track contribute significantly to the overall load transferred to the subgrade. Heavier rails typically necessitate a more robust ballast and formation design.
  6. Track Accessories and Fastenings: Components like rail clips, base plates, and insulators add to the total weight of the track system. While not part of the rail weight calculation itself, they are crucial considerations for installation and overall track design.
  7. Rail Length and Joints: Longer continuous welded rails (CWR) mean fewer joints, reducing complexity and potential points of failure. However, shorter, jointed rails require more fastening components. The calculation here focuses on the rail's intrinsic weight; joint bars add marginal extra weight per joint.

Frequently Asked Questions (FAQ)

Q1: What is the standard rail weight used in most railway lines?

A1: Standard rail weights vary by region and application. However, common weights for mainline tracks include 55 kg/m, 60 kg/m, and sometimes heavier profiles like 70 kg/m or 72 kg/m for high-speed or heavy-haul lines. Lighter rails (e.g., 40-50 kg/m) are often used for industrial sidings, yards, or less critical routes.

Q2: How does rail weight affect train speed and capacity?

A2: Heavier rails generally support higher speeds and greater axle loads. They provide a more stable and robust running surface, reducing track deflection under heavy loads and minimizing wear. Therefore, heavier rails are essential for high-capacity, high-speed main lines.

Q3: Does rail weight change after installation?

A3: No, the intrinsic weight per meter of a rail does not change. However, the overall track system's weight can increase over time due to ballast consolidation, track maintenance activities, or the addition of track accessories.

Q4: Can I use different rail weights on the same track?

A4: It is generally not recommended to mix different rail weights or profiles within the same continuous track section. Doing so can create uneven load distribution, differential wear, and potential safety hazards at the transition points. Transitions require special engineering considerations and specific transition rails.

Q5: What is the difference between rail weight and axle load capacity?

A5: Rail weight is a measure of the rail's mass per unit length. Axle load capacity refers to the maximum weight that can be carried by the wheels on a single axle of a train. While heavier rails can support higher axle loads, the overall axle load capacity of a line is determined by the entire track structure (rail, ballast, sleepers, formation) and operational regulations.

Q6: Where can I find the 'Weight Per Meter' for a specific rail?

A6: The weight per meter is a defining characteristic of a rail profile. This information is typically provided by the rail manufacturer in their product catalogs, technical specifications, or datasheets. Industry standards organizations (like AREMA, UIC, BS) also publish specifications for common rail profiles.

Q7: How important is the 'Number of Rails' input?

A7: The 'Number of Rails' input is crucial for calculating the total weight of a track segment. For standard railway lines, this value is almost always '2' (one rail on each side). However, for specific analyses, such as calculating the weight of material for a siding being delivered, or for specialized track designs, you might need to adjust this number.

Q8: Does this calculator consider rail corrosion or wear?

A8: No, this calculator determines the theoretical weight based on the nominal dimensions and material density of new rails. It does not account for any loss of mass due to corrosion or wear that occurs over the rail's service life. For assessments of existing tracks, a reduction factor based on measured wear might be necessary.

Related Tools and Internal Resources

© 2023 Your Company Name. All rights reserved.

var chartInstance = null; // Global variable to hold chart instance function validateInput(value, id, min, max, required) { var errorElement = document.getElementById(id + "Error"); errorElement.style.display = 'none'; errorElement.textContent = "; if (required && (value === null || value === ")) { errorElement.textContent = 'This field is required.'; errorElement.style.display = 'block'; return false; } if (value === ") return true; // Allow empty if not required, but handle in calculation var numValue = parseFloat(value); if (isNaN(numValue)) { errorElement.textContent = 'Please enter a valid number.'; errorElement.style.display = 'block'; return false; } if (min !== undefined && numValue max) { errorElement.textContent = 'Value must be no more than ' + max + '.'; errorElement.style.display = 'block'; return false; } return true; } function calculateRailWeight() { var railLength = document.getElementById("railLength").value; var railWeightPerMeter = document.getElementById("railWeightPerMeter").value; var numberOfRails = document.getElementById("numberOfRails").value; var errorLength = validateInput(railLength, "railLength", 0, null, true); var errorWeight = validateInput(railWeightPerMeter, "railWeightPerMeter", 0.1, null, true); // Min 0.1 kg/m var errorCount = validateInput(numberOfRails, "numberOfRails", 1, null, true); // Min 1 rail if (!errorLength || !errorWeight || !errorCount) { document.getElementById("main-result").textContent = "–"; updateIntermediateResults("–", "–", "–"); updateTable("–", "–", "–", "–", "–"); updateChart([0, 0]); return; } var numRailLength = parseFloat(railLength); var numRailWeightPerMeter = parseFloat(railWeightPerMeter); var numNumberOfRails = parseFloat(numberOfRails); var totalWeightKg = numRailLength * numRailWeightPerMeter * numNumberOfRails; var totalWeightTonnes = totalWeightKg / 1000; document.getElementById("main-result").textContent = totalWeightTonnes.toFixed(2) + " tonnes"; updateIntermediateResults(totalWeightKg.toFixed(2), totalWeightTonnes.toFixed(2), numRailWeightPerMeter.toFixed(2) + " kg/m"); updateTable(railLength, railWeightPerMeter, numberOfRails, totalWeightKg.toFixed(2), totalWeightTonnes.toFixed(2)); updateChart([numRailWeightPerMeter, totalWeightTonnes]); // Pass values for chart } function updateIntermediateResults(weightKg, weightTonnes, wpm) { document.getElementById("totalWeightMeters").getElementsByTagName("span")[0].textContent = weightKg; document.getElementById("totalWeightTonnes").getElementsByTagName("span")[0].textContent = weightTonnes; document.getElementById("weightPerMeterValue").getElementsByTagName("span")[0].textContent = wpm; } function updateTable(length, wpm, count, weightKg, weightTonnes) { document.getElementById("tableRailLength").textContent = length; document.getElementById("tableWeightPerMeter").textContent = wpm; document.getElementById("tableNumberOfRails").textContent = count; document.getElementById("tableTotalWeightKg").textContent = weightKg; document.getElementById("tableTotalWeightTonnes").textContent = weightTonnes; } function resetCalculator() { document.getElementById("railLength").value = "25"; document.getElementById("railWeightPerMeter").value = "55"; document.getElementById("numberOfRails").value = "2"; // Clear errors var errorElements = document.querySelectorAll('.error-message'); for (var i = 0; i < errorElements.length; i++) { errorElements[i].style.display = 'none'; errorElements[i].textContent = ''; } calculateRailWeight(); // Recalculate with default values } function copyResults() { var mainResult = document.getElementById("main-result").textContent; var totalWeightKg = document.getElementById("totalWeightMeters").getElementsByTagName("span")[0].textContent; var totalWeightTonnes = document.getElementById("totalWeightTonnes").getElementsByTagName("span")[0].textContent; var weightPerMeter = document.getElementById("weightPerMeterValue").getElementsByTagName("span")[0].textContent; var railLength = document.getElementById("railLength").value; var wpmInput = document.getElementById("railWeightPerMeter").value; var numRailsInput = document.getElementById("numberOfRails").value; var clipboardText = "— Rail Weight Calculation Results —\n\n"; clipboardText += "Primary Result: " + mainResult + "\n\n"; clipboardText += "— Key Values —\n"; clipboardText += "Total Weight (kg): " + totalWeightKg + "\n"; clipboardText += "Total Weight (tonnes): " + totalWeightTonnes + "\n"; clipboardText += "Weight Per Meter Used: " + wpm + "\n\n"; clipboardText += "— Input Assumptions —\n"; clipboardText += "Rail Length: " + railLength + " m\n"; clipboardText += "Weight Per Meter: " + wpmInput + " kg/m\n"; clipboardText += "Number of Rails: " + numRailsInput + "\n"; navigator.clipboard.writeText(clipboardText).then(function() { // Success feedback var button = document.getElementById("copy-results-button"); button.textContent = "Copied!"; button.style.backgroundColor = "#28a745"; setTimeout(function() { button.textContent = "Copy Results"; button.style.backgroundColor = "#ffc107"; }, 2000); }).catch(function(err) { console.error("Failed to copy text: ", err); alert("Failed to copy results. Please copy manually."); }); } // Charting Functionality function updateChart(data) { var ctx = document.getElementById('weightChart').getContext('2d'); // Destroy previous chart instance if it exists if (chartInstance) { chartInstance.destroy(); } var railWeightPerMeter = parseFloat(data[0]); var totalWeightTonnes = parseFloat(data[1]); var individualRailWeightTonnes = isNaN(railWeightPerMeter) ? 0 : (railWeightPerMeter * parseFloat(document.getElementById("railLength").value)) / 1000; var numberOfRails = parseInt(document.getElementById("numberOfRails").value) || 2; // Default to 2 if invalid // Ensure we handle cases where totalWeightTonnes might be NaN or 0 if (isNaN(totalWeightTonnes) || totalWeightTonnes === 0) { individualRailWeightTonnes = 0; totalWeightTonnes = 0; } chartInstance = new Chart(ctx, { type: 'bar', data: { labels: ['Individual Rail Segment (tonnes)', 'Total Track Segment (tonnes)'], datasets: [{ label: 'Weight', data: [individualRailWeightTonnes, totalWeightTonnes], backgroundColor: [ 'rgba(0, 74, 153, 0.6)', // Primary color for individual rail 'rgba(40, 167, 69, 0.6)' // Success color for total ], borderColor: [ 'rgba(0, 74, 153, 1)', 'rgba(40, 167, 69, 1)' ], borderWidth: 1 }] }, options: { responsive: true, maintainAspectRatio: true, scales: { y: { beginAtZero: true, title: { display: true, text: 'Weight (tonnes)' } } }, plugins: { legend: { display: false // Hide legend as labels are on the axis }, title: { display: true, text: 'Comparison of Rail Segment Weights' } } } }); } // Initial calculation and chart rendering on page load window.onload = function() { // Ensure Chart.js is loaded – if not, you'd need to include it via CDN in the head // For this self-contained example, we assume Chart.js is available globally. // If you were actually deploying this, you'd add: // // to the or before the closing tag. // Dummy Chart.js object for testing if not actually loaded: if (typeof Chart === 'undefined') { console.warn("Chart.js not found. Chart will not render."); window.Chart = function() { this.destroy = function() { console.log('Dummy destroy called'); }; }; } resetCalculator(); // Set default values and calculate updateChart([0,0]); // Initialize chart with zero values }; <!– NOTE: For the chart to work, Chart.js library must be included. Add this line in the or before the closing tag: –>

Leave a Comment