text:
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by \generate-code.bat.
//
//     Changes to this file will be lost when the code is regenerated.
//     The build server regenerates the code before each build and a pre-build
//     step will regenerate the code on each local build.
//
//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
//
//     Add CustomCode\Quantities\MyUnit.extra.cs files to add code to generated quantities.
//     Add Extensions\MyUnitExtensions.cs to decorate quantities with new behavior.
//     Add UnitDefinitions\MyUnit.json and run GeneratUnits.bat to generate new units or quantities.
//
// </auto-generated>
//------------------------------------------------------------------------------

// Copyright (c) 2007 Andreas Gullberg Larsen (angularsen@gmail.com).
// https://github.com/angularsen/UnitsNet
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text.RegularExpressions;
using System.Linq;
using JetBrains.Annotations;
using UnitsNet.Units;

// Windows Runtime Component does not support CultureInfo type, so use culture name string instead for public methods: https://msdn.microsoft.com/en-us/library/br230301.aspx
#if WINDOWS_UWP
using Culture = System.String;
#else
using Culture = System.IFormatProvider;
#endif

// ReSharper disable once CheckNamespace

namespace UnitsNet
{
    /// <summary>
    ///     In physics and engineering, in particular fluid dynamics and hydrometry, the volumetric flow rate, (also known as volume flow rate, rate of fluid flow or volume velocity) is the volume of fluid which passes through a given surface per unit time. The SI unit is m3·s−1 (cubic meters per second). In US Customary Units and British Imperial Units, volumetric flow rate is often expressed as ft3/s (cubic feet per second). It is usually represented by the symbol Q.
    /// </summary>
    // ReSharper disable once PartialTypeWithSinglePart

    // Windows Runtime Component has constraints on public types: https://msdn.microsoft.com/en-us/library/br230301.aspx#Declaring types in Windows Runtime Components
    // Public structures can't have any members other than public fields, and those fields must be value types or strings.
    // Public classes must be sealed (NotInheritable in Visual Basic). If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic.
#if WINDOWS_UWP
    public sealed partial class Flow
#else
    public partial struct Flow : IComparable, IComparable<Flow>
#endif
    {
        /// <summary>
        ///     Base unit of Flow.
        /// </summary>
        private readonly double _cubicMetersPerSecond;

        // Windows Runtime Component requires a default constructor
#if WINDOWS_UWP
        public Flow() : this(0)
        {
        }
#endif

        public Flow(double cubicmeterspersecond)
        {
            _cubicMetersPerSecond = Convert.ToDouble(cubicmeterspersecond);
        }

        // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods
#if WINDOWS_UWP
        private
#else
        public
#endif
        Flow(long cubicmeterspersecond)
        {
            _cubicMetersPerSecond = Convert.ToDouble(cubicmeterspersecond);
        }

        // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods
        // Windows Runtime Component does not support decimal type
#if WINDOWS_UWP
        private
#else
        public
#endif
        Flow(decimal cubicmeterspersecond)
        {
            _cubicMetersPerSecond = Convert.ToDouble(cubicmeterspersecond);
        }

        #region Properties

        /// <summary>
        ///     The <see cref="QuantityType" /> of this quantity.
        /// </summary>
        public static QuantityType QuantityType => QuantityType.Flow;

        /// <summary>
        ///     The base unit representation of this quantity for the numeric value stored internally. All conversions go via this value.
        /// </summary>
        public static FlowUnit BaseUnit
        {
            get { return FlowUnit.CubicMeterPerSecond; }
        }

        /// <summary>
        ///     All units of measurement for the Flow quantity.
        /// </summary>
        public static FlowUnit[] Units { get; } = Enum.GetValues(typeof(FlowUnit)).Cast<FlowUnit>().ToArray();

        /// <summary>
        ///     Get Flow in CentilitersPerMinute.
        /// </summary>
        public double CentilitersPerMinute
        {
            get { return (_cubicMetersPerSecond*60000.00000) / 1e-2d; }
        }

        /// <summary>
        ///     Get Flow in CubicDecimetersPerMinute.
        /// </summary>
        public double CubicDecimetersPerMinute
        {
            get { return _cubicMetersPerSecond*60000.00000; }
        }

        /// <summary>
        ///     Get Flow in CubicFeetPerHour.
        /// </summary>
        public double CubicFeetPerHour
        {
            get { return _cubicMetersPerSecond/7.8657907199999087346816086183876e-6; }
        }

        /// <summary>
        ///     Get Flow in CubicFeetPerSecond.
        /// </summary>
        public double CubicFeetPerSecond
        {
            get { return _cubicMetersPerSecond*35.314666721; }
        }

        /// <summary>
        ///     Get Flow in CubicMetersPerHour.
        /// </summary>
        public double CubicMetersPerHour
        {
            get { return _cubicMetersPerSecond*3600; }
        }

        /// <summary>
        ///     Get Flow in CubicMetersPerSecond.
        /// </summary>
        public double CubicMetersPerSecond
        {
            get { return _cubicMetersPerSecond; }
        }

        /// <summary>
        ///     Get Flow in DecilitersPerMinute.
        /// </summary>
        public double DecilitersPerMinute
        {
            get { return (_cubicMetersPerSecond*60000.00000) / 1e-1d; }
        }

        /// <summary>
        ///     Get Flow in KilolitersPerMinute.
        /// </summary>
        public double KilolitersPerMinute
        {
            get { return (_cubicMetersPerSecond*60000.00000) / 1e3d; }
        }

        /// <summary>
        ///     Get Flow in LitersPerHour.
        /// </summary>
        public double LitersPerHour
        {
            get { return _cubicMetersPerSecond*3600000.000; }
        }

        /// <summary>
        ///     Get Flow in LitersPerMinute.
        /// </summary>
        public double LitersPerMinute
        {
            get { return _cubicMetersPerSecond*60000.00000; }
        }

        /// <summary>
        ///     Get Flow in LitersPerSecond.
        /// </summary>
        public double LitersPerSecond
        {
            get { return _cubicMetersPerSecond*1000; }
        }

        /// <summary>
        ///     Get Flow in MicrolitersPerMinute.
        /// </summary>
        public double MicrolitersPerMinute
        {
            get { return (_cubicMetersPerSecond*60000.00000) / 1e-6d; }
        }

        /// <summary>
        ///     Get Flow in MillilitersPerMinute.
        /// </summary>
        public double MillilitersPerMinute
        {
            get { return (_cubicMetersPerSecond*60000.00000) / 1e-3d; }
        }

        /// <summary>
        ///     Get Flow in MillionUsGallonsPerDay.
        /// </summary>
        public double MillionUsGallonsPerDay
        {
            get { return _cubicMetersPerSecond*22.824465227; }
        }

        /// <summary>
        ///     Get Flow in NanolitersPerMinute.
        /// </summary>
        public double NanolitersPerMinute
        {
            get { return (_cubicMetersPerSecond*60000.00000) / 1e-9d; }
        }

        /// <summary>
        ///     Get Flow in OilBarrelsPerDay.
        /// </summary>
        public double OilBarrelsPerDay
        {
            get { return _cubicMetersPerSecond/1.8401307283333333333333333333333e-6; }
        }

        /// <summary>
        ///     Get Flow in UsGallonsPerMinute.
        /// </summary>
        public double UsGallonsPerMinute
        {
            get { return _cubicMetersPerSecond*15850.323141489; }
        }

        #endregion

        #region Static

        public static Flow Zero
        {
            get { return new Flow(); }
        }

        /// <summary>
        ///     Get Flow from CentilitersPerMinute.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromCentilitersPerMinute(double centilitersperminute)
        {
            return new Flow((centilitersperminute/60000.00000) * 1e-2d);
        }

        /// <summary>
        ///     Get Flow from CentilitersPerMinute.
        /// </summary>
        public static Flow FromCentilitersPerMinute(int centilitersperminute)
        {
            return new Flow((centilitersperminute/60000.00000) * 1e-2d);
        }

        /// <summary>
        ///     Get Flow from CentilitersPerMinute.
        /// </summary>
        public static Flow FromCentilitersPerMinute(long centilitersperminute)
        {
            return new Flow((centilitersperminute/60000.00000) * 1e-2d);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from CentilitersPerMinute of type decimal.
        /// </summary>
        public static Flow FromCentilitersPerMinute(decimal centilitersperminute)
        {
            return new Flow((Convert.ToDouble(centilitersperminute)/60000.00000) * 1e-2d);
        }
#endif

        /// <summary>
        ///     Get Flow from CubicDecimetersPerMinute.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromCubicDecimetersPerMinute(double cubicdecimetersperminute)
        {
            return new Flow(cubicdecimetersperminute/60000.00000);
        }

        /// <summary>
        ///     Get Flow from CubicDecimetersPerMinute.
        /// </summary>
        public static Flow FromCubicDecimetersPerMinute(int cubicdecimetersperminute)
        {
            return new Flow(cubicdecimetersperminute/60000.00000);
        }

        /// <summary>
        ///     Get Flow from CubicDecimetersPerMinute.
        /// </summary>
        public static Flow FromCubicDecimetersPerMinute(long cubicdecimetersperminute)
        {
            return new Flow(cubicdecimetersperminute/60000.00000);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from CubicDecimetersPerMinute of type decimal.
        /// </summary>
        public static Flow FromCubicDecimetersPerMinute(decimal cubicdecimetersperminute)
        {
            return new Flow(Convert.ToDouble(cubicdecimetersperminute)/60000.00000);
        }
#endif

        /// <summary>
        ///     Get Flow from CubicFeetPerHour.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromCubicFeetPerHour(double cubicfeetperhour)
        {
            return new Flow(cubicfeetperhour*7.8657907199999087346816086183876e-6);
        }

        /// <summary>
        ///     Get Flow from CubicFeetPerHour.
        /// </summary>
        public static Flow FromCubicFeetPerHour(int cubicfeetperhour)
        {
            return new Flow(cubicfeetperhour*7.8657907199999087346816086183876e-6);
        }

        /// <summary>
        ///     Get Flow from CubicFeetPerHour.
        /// </summary>
        public static Flow FromCubicFeetPerHour(long cubicfeetperhour)
        {
            return new Flow(cubicfeetperhour*7.8657907199999087346816086183876e-6);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from CubicFeetPerHour of type decimal.
        /// </summary>
        public static Flow FromCubicFeetPerHour(decimal cubicfeetperhour)
        {
            return new Flow(Convert.ToDouble(cubicfeetperhour)*7.8657907199999087346816086183876e-6);
        }
#endif

        /// <summary>
        ///     Get Flow from CubicFeetPerSecond.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromCubicFeetPerSecond(double cubicfeetpersecond)
        {
            return new Flow(cubicfeetpersecond/35.314666721);
        }

        /// <summary>
        ///     Get Flow from CubicFeetPerSecond.
        /// </summary>
        public static Flow FromCubicFeetPerSecond(int cubicfeetpersecond)
        {
            return new Flow(cubicfeetpersecond/35.314666721);
        }

        /// <summary>
        ///     Get Flow from CubicFeetPerSecond.
        /// </summary>
        public static Flow FromCubicFeetPerSecond(long cubicfeetpersecond)
        {
            return new Flow(cubicfeetpersecond/35.314666721);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from CubicFeetPerSecond of type decimal.
        /// </summary>
        public static Flow FromCubicFeetPerSecond(decimal cubicfeetpersecond)
        {
            return new Flow(Convert.ToDouble(cubicfeetpersecond)/35.314666721);
        }
#endif

        /// <summary>
        ///     Get Flow from CubicMetersPerHour.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromCubicMetersPerHour(double cubicmetersperhour)
        {
            return new Flow(cubicmetersperhour/3600);
        }

        /// <summary>
        ///     Get Flow from CubicMetersPerHour.
        /// </summary>
        public static Flow FromCubicMetersPerHour(int cubicmetersperhour)
        {
            return new Flow(cubicmetersperhour/3600);
        }

        /// <summary>
        ///     Get Flow from CubicMetersPerHour.
        /// </summary>
        public static Flow FromCubicMetersPerHour(long cubicmetersperhour)
        {
            return new Flow(cubicmetersperhour/3600);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from CubicMetersPerHour of type decimal.
        /// </summary>
        public static Flow FromCubicMetersPerHour(decimal cubicmetersperhour)
        {
            return new Flow(Convert.ToDouble(cubicmetersperhour)/3600);
        }
#endif

        /// <summary>
        ///     Get Flow from CubicMetersPerSecond.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromCubicMetersPerSecond(double cubicmeterspersecond)
        {
            return new Flow(cubicmeterspersecond);
        }

        /// <summary>
        ///     Get Flow from CubicMetersPerSecond.
        /// </summary>
        public static Flow FromCubicMetersPerSecond(int cubicmeterspersecond)
        {
            return new Flow(cubicmeterspersecond);
        }

        /// <summary>
        ///     Get Flow from CubicMetersPerSecond.
        /// </summary>
        public static Flow FromCubicMetersPerSecond(long cubicmeterspersecond)
        {
            return new Flow(cubicmeterspersecond);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from CubicMetersPerSecond of type decimal.
        /// </summary>
        public static Flow FromCubicMetersPerSecond(decimal cubicmeterspersecond)
        {
            return new Flow(Convert.ToDouble(cubicmeterspersecond));
        }
#endif

        /// <summary>
        ///     Get Flow from DecilitersPerMinute.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromDecilitersPerMinute(double decilitersperminute)
        {
            return new Flow((decilitersperminute/60000.00000) * 1e-1d);
        }

        /// <summary>
        ///     Get Flow from DecilitersPerMinute.
        /// </summary>
        public static Flow FromDecilitersPerMinute(int decilitersperminute)
        {
            return new Flow((decilitersperminute/60000.00000) * 1e-1d);
        }

        /// <summary>
        ///     Get Flow from DecilitersPerMinute.
        /// </summary>
        public static Flow FromDecilitersPerMinute(long decilitersperminute)
        {
            return new Flow((decilitersperminute/60000.00000) * 1e-1d);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from DecilitersPerMinute of type decimal.
        /// </summary>
        public static Flow FromDecilitersPerMinute(decimal decilitersperminute)
        {
            return new Flow((Convert.ToDouble(decilitersperminute)/60000.00000) * 1e-1d);
        }
#endif

        /// <summary>
        ///     Get Flow from KilolitersPerMinute.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromKilolitersPerMinute(double kilolitersperminute)
        {
            return new Flow((kilolitersperminute/60000.00000) * 1e3d);
        }

        /// <summary>
        ///     Get Flow from KilolitersPerMinute.
        /// </summary>
        public static Flow FromKilolitersPerMinute(int kilolitersperminute)
        {
            return new Flow((kilolitersperminute/60000.00000) * 1e3d);
        }

        /// <summary>
        ///     Get Flow from KilolitersPerMinute.
        /// </summary>
        public static Flow FromKilolitersPerMinute(long kilolitersperminute)
        {
            return new Flow((kilolitersperminute/60000.00000) * 1e3d);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from KilolitersPerMinute of type decimal.
        /// </summary>
        public static Flow FromKilolitersPerMinute(decimal kilolitersperminute)
        {
            return new Flow((Convert.ToDouble(kilolitersperminute)/60000.00000) * 1e3d);
        }
#endif

        /// <summary>
        ///     Get Flow from LitersPerHour.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromLitersPerHour(double litersperhour)
        {
            return new Flow(litersperhour/3600000.000);
        }

        /// <summary>
        ///     Get Flow from LitersPerHour.
        /// </summary>
        public static Flow FromLitersPerHour(int litersperhour)
        {
            return new Flow(litersperhour/3600000.000);
        }

        /// <summary>
        ///     Get Flow from LitersPerHour.
        /// </summary>
        public static Flow FromLitersPerHour(long litersperhour)
        {
            return new Flow(litersperhour/3600000.000);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from LitersPerHour of type decimal.
        /// </summary>
        public static Flow FromLitersPerHour(decimal litersperhour)
        {
            return new Flow(Convert.ToDouble(litersperhour)/3600000.000);
        }
#endif

        /// <summary>
        ///     Get Flow from LitersPerMinute.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromLitersPerMinute(double litersperminute)
        {
            return new Flow(litersperminute/60000.00000);
        }

        /// <summary>
        ///     Get Flow from LitersPerMinute.
        /// </summary>
        public static Flow FromLitersPerMinute(int litersperminute)
        {
            return new Flow(litersperminute/60000.00000);
        }

        /// <summary>
        ///     Get Flow from LitersPerMinute.
        /// </summary>
        public static Flow FromLitersPerMinute(long litersperminute)
        {
            return new Flow(litersperminute/60000.00000);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from LitersPerMinute of type decimal.
        /// </summary>
        public static Flow FromLitersPerMinute(decimal litersperminute)
        {
            return new Flow(Convert.ToDouble(litersperminute)/60000.00000);
        }
#endif

        /// <summary>
        ///     Get Flow from LitersPerSecond.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromLitersPerSecond(double literspersecond)
        {
            return new Flow(literspersecond/1000);
        }

        /// <summary>
        ///     Get Flow from LitersPerSecond.
        /// </summary>
        public static Flow FromLitersPerSecond(int literspersecond)
        {
            return new Flow(literspersecond/1000);
        }

        /// <summary>
        ///     Get Flow from LitersPerSecond.
        /// </summary>
        public static Flow FromLitersPerSecond(long literspersecond)
        {
            return new Flow(literspersecond/1000);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from LitersPerSecond of type decimal.
        /// </summary>
        public static Flow FromLitersPerSecond(decimal literspersecond)
        {
            return new Flow(Convert.ToDouble(literspersecond)/1000);
        }
#endif

        /// <summary>
        ///     Get Flow from MicrolitersPerMinute.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromMicrolitersPerMinute(double microlitersperminute)
        {
            return new Flow((microlitersperminute/60000.00000) * 1e-6d);
        }

        /// <summary>
        ///     Get Flow from MicrolitersPerMinute.
        /// </summary>
        public static Flow FromMicrolitersPerMinute(int microlitersperminute)
        {
            return new Flow((microlitersperminute/60000.00000) * 1e-6d);
        }

        /// <summary>
        ///     Get Flow from MicrolitersPerMinute.
        /// </summary>
        public static Flow FromMicrolitersPerMinute(long microlitersperminute)
        {
            return new Flow((microlitersperminute/60000.00000) * 1e-6d);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from MicrolitersPerMinute of type decimal.
        /// </summary>
        public static Flow FromMicrolitersPerMinute(decimal microlitersperminute)
        {
            return new Flow((Convert.ToDouble(microlitersperminute)/60000.00000) * 1e-6d);
        }
#endif

        /// <summary>
        ///     Get Flow from MillilitersPerMinute.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromMillilitersPerMinute(double millilitersperminute)
        {
            return new Flow((millilitersperminute/60000.00000) * 1e-3d);
        }

        /// <summary>
        ///     Get Flow from MillilitersPerMinute.
        /// </summary>
        public static Flow FromMillilitersPerMinute(int millilitersperminute)
        {
            return new Flow((millilitersperminute/60000.00000) * 1e-3d);
        }

        /// <summary>
        ///     Get Flow from MillilitersPerMinute.
        /// </summary>
        public static Flow FromMillilitersPerMinute(long millilitersperminute)
        {
            return new Flow((millilitersperminute/60000.00000) * 1e-3d);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from MillilitersPerMinute of type decimal.
        /// </summary>
        public static Flow FromMillilitersPerMinute(decimal millilitersperminute)
        {
            return new Flow((Convert.ToDouble(millilitersperminute)/60000.00000) * 1e-3d);
        }
#endif

        /// <summary>
        ///     Get Flow from MillionUsGallonsPerDay.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromMillionUsGallonsPerDay(double millionusgallonsperday)
        {
            return new Flow(millionusgallonsperday/22.824465227);
        }

        /// <summary>
        ///     Get Flow from MillionUsGallonsPerDay.
        /// </summary>
        public static Flow FromMillionUsGallonsPerDay(int millionusgallonsperday)
        {
            return new Flow(millionusgallonsperday/22.824465227);
        }

        /// <summary>
        ///     Get Flow from MillionUsGallonsPerDay.
        /// </summary>
        public static Flow FromMillionUsGallonsPerDay(long millionusgallonsperday)
        {
            return new Flow(millionusgallonsperday/22.824465227);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from MillionUsGallonsPerDay of type decimal.
        /// </summary>
        public static Flow FromMillionUsGallonsPerDay(decimal millionusgallonsperday)
        {
            return new Flow(Convert.ToDouble(millionusgallonsperday)/22.824465227);
        }
#endif

        /// <summary>
        ///     Get Flow from NanolitersPerMinute.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromNanolitersPerMinute(double nanolitersperminute)
        {
            return new Flow((nanolitersperminute/60000.00000) * 1e-9d);
        }

        /// <summary>
        ///     Get Flow from NanolitersPerMinute.
        /// </summary>
        public static Flow FromNanolitersPerMinute(int nanolitersperminute)
        {
            return new Flow((nanolitersperminute/60000.00000) * 1e-9d);
        }

        /// <summary>
        ///     Get Flow from NanolitersPerMinute.
        /// </summary>
        public static Flow FromNanolitersPerMinute(long nanolitersperminute)
        {
            return new Flow((nanolitersperminute/60000.00000) * 1e-9d);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from NanolitersPerMinute of type decimal.
        /// </summary>
        public static Flow FromNanolitersPerMinute(decimal nanolitersperminute)
        {
            return new Flow((Convert.ToDouble(nanolitersperminute)/60000.00000) * 1e-9d);
        }
#endif

        /// <summary>
        ///     Get Flow from OilBarrelsPerDay.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromOilBarrelsPerDay(double oilbarrelsperday)
        {
            return new Flow(oilbarrelsperday*1.8401307283333333333333333333333e-6);
        }

        /// <summary>
        ///     Get Flow from OilBarrelsPerDay.
        /// </summary>
        public static Flow FromOilBarrelsPerDay(int oilbarrelsperday)
        {
            return new Flow(oilbarrelsperday*1.8401307283333333333333333333333e-6);
        }

        /// <summary>
        ///     Get Flow from OilBarrelsPerDay.
        /// </summary>
        public static Flow FromOilBarrelsPerDay(long oilbarrelsperday)
        {
            return new Flow(oilbarrelsperday*1.8401307283333333333333333333333e-6);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from OilBarrelsPerDay of type decimal.
        /// </summary>
        public static Flow FromOilBarrelsPerDay(decimal oilbarrelsperday)
        {
            return new Flow(Convert.ToDouble(oilbarrelsperday)*1.8401307283333333333333333333333e-6);
        }
#endif

        /// <summary>
        ///     Get Flow from UsGallonsPerMinute.
        /// </summary>
#if NETFX_CORE
        [Windows.Foundation.Metadata.DefaultOverload]
#endif
        public static Flow FromUsGallonsPerMinute(double usgallonsperminute)
        {
            return new Flow(usgallonsperminute/15850.323141489);
        }

        /// <summary>
        ///     Get Flow from UsGallonsPerMinute.
        /// </summary>
        public static Flow FromUsGallonsPerMinute(int usgallonsperminute)
        {
            return new Flow(usgallonsperminute/15850.323141489);
        }

        /// <summary>
        ///     Get Flow from UsGallonsPerMinute.
        /// </summary>
        public static Flow FromUsGallonsPerMinute(long usgallonsperminute)
        {
            return new Flow(usgallonsperminute/15850.323141489);
        }

        // Windows Runtime Component does not support decimal type
#if !WINDOWS_UWP
        /// <summary>
        ///     Get Flow from UsGallonsPerMinute of type decimal.
        /// </summary>
        public static Flow FromUsGallonsPerMinute(decimal usgallonsperminute)
        {
            return new Flow(Convert.ToDouble(usgallonsperminute)/15850.323141489);
        }
#endif

        // Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx
#if !WINDOWS_UWP
        /// <summary>
        ///     Get nullable Flow from nullable CentilitersPerMinute.
        /// </summary>
        public static Flow? FromCentilitersPerMinute(double? centilitersperminute)
        {
            if (centilitersperminute.HasValue)
            {
                return FromCentilitersPerMinute(centilitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CentilitersPerMinute.
        /// </summary>
        public static Flow? FromCentilitersPerMinute(int? centilitersperminute)
        {
            if (centilitersperminute.HasValue)
            {
                return FromCentilitersPerMinute(centilitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CentilitersPerMinute.
        /// </summary>
        public static Flow? FromCentilitersPerMinute(long? centilitersperminute)
        {
            if (centilitersperminute.HasValue)
            {
                return FromCentilitersPerMinute(centilitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from CentilitersPerMinute of type decimal.
        /// </summary>
        public static Flow? FromCentilitersPerMinute(decimal? centilitersperminute)
        {
            if (centilitersperminute.HasValue)
            {
                return FromCentilitersPerMinute(centilitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicDecimetersPerMinute.
        /// </summary>
        public static Flow? FromCubicDecimetersPerMinute(double? cubicdecimetersperminute)
        {
            if (cubicdecimetersperminute.HasValue)
            {
                return FromCubicDecimetersPerMinute(cubicdecimetersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicDecimetersPerMinute.
        /// </summary>
        public static Flow? FromCubicDecimetersPerMinute(int? cubicdecimetersperminute)
        {
            if (cubicdecimetersperminute.HasValue)
            {
                return FromCubicDecimetersPerMinute(cubicdecimetersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicDecimetersPerMinute.
        /// </summary>
        public static Flow? FromCubicDecimetersPerMinute(long? cubicdecimetersperminute)
        {
            if (cubicdecimetersperminute.HasValue)
            {
                return FromCubicDecimetersPerMinute(cubicdecimetersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from CubicDecimetersPerMinute of type decimal.
        /// </summary>
        public static Flow? FromCubicDecimetersPerMinute(decimal? cubicdecimetersperminute)
        {
            if (cubicdecimetersperminute.HasValue)
            {
                return FromCubicDecimetersPerMinute(cubicdecimetersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicFeetPerHour.
        /// </summary>
        public static Flow? FromCubicFeetPerHour(double? cubicfeetperhour)
        {
            if (cubicfeetperhour.HasValue)
            {
                return FromCubicFeetPerHour(cubicfeetperhour.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicFeetPerHour.
        /// </summary>
        public static Flow? FromCubicFeetPerHour(int? cubicfeetperhour)
        {
            if (cubicfeetperhour.HasValue)
            {
                return FromCubicFeetPerHour(cubicfeetperhour.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicFeetPerHour.
        /// </summary>
        public static Flow? FromCubicFeetPerHour(long? cubicfeetperhour)
        {
            if (cubicfeetperhour.HasValue)
            {
                return FromCubicFeetPerHour(cubicfeetperhour.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from CubicFeetPerHour of type decimal.
        /// </summary>
        public static Flow? FromCubicFeetPerHour(decimal? cubicfeetperhour)
        {
            if (cubicfeetperhour.HasValue)
            {
                return FromCubicFeetPerHour(cubicfeetperhour.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicFeetPerSecond.
        /// </summary>
        public static Flow? FromCubicFeetPerSecond(double? cubicfeetpersecond)
        {
            if (cubicfeetpersecond.HasValue)
            {
                return FromCubicFeetPerSecond(cubicfeetpersecond.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicFeetPerSecond.
        /// </summary>
        public static Flow? FromCubicFeetPerSecond(int? cubicfeetpersecond)
        {
            if (cubicfeetpersecond.HasValue)
            {
                return FromCubicFeetPerSecond(cubicfeetpersecond.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicFeetPerSecond.
        /// </summary>
        public static Flow? FromCubicFeetPerSecond(long? cubicfeetpersecond)
        {
            if (cubicfeetpersecond.HasValue)
            {
                return FromCubicFeetPerSecond(cubicfeetpersecond.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from CubicFeetPerSecond of type decimal.
        /// </summary>
        public static Flow? FromCubicFeetPerSecond(decimal? cubicfeetpersecond)
        {
            if (cubicfeetpersecond.HasValue)
            {
                return FromCubicFeetPerSecond(cubicfeetpersecond.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicMetersPerHour.
        /// </summary>
        public static Flow? FromCubicMetersPerHour(double? cubicmetersperhour)
        {
            if (cubicmetersperhour.HasValue)
            {
                return FromCubicMetersPerHour(cubicmetersperhour.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicMetersPerHour.
        /// </summary>
        public static Flow? FromCubicMetersPerHour(int? cubicmetersperhour)
        {
            if (cubicmetersperhour.HasValue)
            {
                return FromCubicMetersPerHour(cubicmetersperhour.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicMetersPerHour.
        /// </summary>
        public static Flow? FromCubicMetersPerHour(long? cubicmetersperhour)
        {
            if (cubicmetersperhour.HasValue)
            {
                return FromCubicMetersPerHour(cubicmetersperhour.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from CubicMetersPerHour of type decimal.
        /// </summary>
        public static Flow? FromCubicMetersPerHour(decimal? cubicmetersperhour)
        {
            if (cubicmetersperhour.HasValue)
            {
                return FromCubicMetersPerHour(cubicmetersperhour.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicMetersPerSecond.
        /// </summary>
        public static Flow? FromCubicMetersPerSecond(double? cubicmeterspersecond)
        {
            if (cubicmeterspersecond.HasValue)
            {
                return FromCubicMetersPerSecond(cubicmeterspersecond.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicMetersPerSecond.
        /// </summary>
        public static Flow? FromCubicMetersPerSecond(int? cubicmeterspersecond)
        {
            if (cubicmeterspersecond.HasValue)
            {
                return FromCubicMetersPerSecond(cubicmeterspersecond.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable CubicMetersPerSecond.
        /// </summary>
        public static Flow? FromCubicMetersPerSecond(long? cubicmeterspersecond)
        {
            if (cubicmeterspersecond.HasValue)
            {
                return FromCubicMetersPerSecond(cubicmeterspersecond.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from CubicMetersPerSecond of type decimal.
        /// </summary>
        public static Flow? FromCubicMetersPerSecond(decimal? cubicmeterspersecond)
        {
            if (cubicmeterspersecond.HasValue)
            {
                return FromCubicMetersPerSecond(cubicmeterspersecond.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable DecilitersPerMinute.
        /// </summary>
        public static Flow? FromDecilitersPerMinute(double? decilitersperminute)
        {
            if (decilitersperminute.HasValue)
            {
                return FromDecilitersPerMinute(decilitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable DecilitersPerMinute.
        /// </summary>
        public static Flow? FromDecilitersPerMinute(int? decilitersperminute)
        {
            if (decilitersperminute.HasValue)
            {
                return FromDecilitersPerMinute(decilitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable DecilitersPerMinute.
        /// </summary>
        public static Flow? FromDecilitersPerMinute(long? decilitersperminute)
        {
            if (decilitersperminute.HasValue)
            {
                return FromDecilitersPerMinute(decilitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from DecilitersPerMinute of type decimal.
        /// </summary>
        public static Flow? FromDecilitersPerMinute(decimal? decilitersperminute)
        {
            if (decilitersperminute.HasValue)
            {
                return FromDecilitersPerMinute(decilitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable KilolitersPerMinute.
        /// </summary>
        public static Flow? FromKilolitersPerMinute(double? kilolitersperminute)
        {
            if (kilolitersperminute.HasValue)
            {
                return FromKilolitersPerMinute(kilolitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable KilolitersPerMinute.
        /// </summary>
        public static Flow? FromKilolitersPerMinute(int? kilolitersperminute)
        {
            if (kilolitersperminute.HasValue)
            {
                return FromKilolitersPerMinute(kilolitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable KilolitersPerMinute.
        /// </summary>
        public static Flow? FromKilolitersPerMinute(long? kilolitersperminute)
        {
            if (kilolitersperminute.HasValue)
            {
                return FromKilolitersPerMinute(kilolitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from KilolitersPerMinute of type decimal.
        /// </summary>
        public static Flow? FromKilolitersPerMinute(decimal? kilolitersperminute)
        {
            if (kilolitersperminute.HasValue)
            {
                return FromKilolitersPerMinute(kilolitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable LitersPerHour.
        /// </summary>
        public static Flow? FromLitersPerHour(double? litersperhour)
        {
            if (litersperhour.HasValue)
            {
                return FromLitersPerHour(litersperhour.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable LitersPerHour.
        /// </summary>
        public static Flow? FromLitersPerHour(int? litersperhour)
        {
            if (litersperhour.HasValue)
            {
                return FromLitersPerHour(litersperhour.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable LitersPerHour.
        /// </summary>
        public static Flow? FromLitersPerHour(long? litersperhour)
        {
            if (litersperhour.HasValue)
            {
                return FromLitersPerHour(litersperhour.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from LitersPerHour of type decimal.
        /// </summary>
        public static Flow? FromLitersPerHour(decimal? litersperhour)
        {
            if (litersperhour.HasValue)
            {
                return FromLitersPerHour(litersperhour.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable LitersPerMinute.
        /// </summary>
        public static Flow? FromLitersPerMinute(double? litersperminute)
        {
            if (litersperminute.HasValue)
            {
                return FromLitersPerMinute(litersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable LitersPerMinute.
        /// </summary>
        public static Flow? FromLitersPerMinute(int? litersperminute)
        {
            if (litersperminute.HasValue)
            {
                return FromLitersPerMinute(litersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable LitersPerMinute.
        /// </summary>
        public static Flow? FromLitersPerMinute(long? litersperminute)
        {
            if (litersperminute.HasValue)
            {
                return FromLitersPerMinute(litersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from LitersPerMinute of type decimal.
        /// </summary>
        public static Flow? FromLitersPerMinute(decimal? litersperminute)
        {
            if (litersperminute.HasValue)
            {
                return FromLitersPerMinute(litersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable LitersPerSecond.
        /// </summary>
        public static Flow? FromLitersPerSecond(double? literspersecond)
        {
            if (literspersecond.HasValue)
            {
                return FromLitersPerSecond(literspersecond.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable LitersPerSecond.
        /// </summary>
        public static Flow? FromLitersPerSecond(int? literspersecond)
        {
            if (literspersecond.HasValue)
            {
                return FromLitersPerSecond(literspersecond.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable LitersPerSecond.
        /// </summary>
        public static Flow? FromLitersPerSecond(long? literspersecond)
        {
            if (literspersecond.HasValue)
            {
                return FromLitersPerSecond(literspersecond.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from LitersPerSecond of type decimal.
        /// </summary>
        public static Flow? FromLitersPerSecond(decimal? literspersecond)
        {
            if (literspersecond.HasValue)
            {
                return FromLitersPerSecond(literspersecond.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable MicrolitersPerMinute.
        /// </summary>
        public static Flow? FromMicrolitersPerMinute(double? microlitersperminute)
        {
            if (microlitersperminute.HasValue)
            {
                return FromMicrolitersPerMinute(microlitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable MicrolitersPerMinute.
        /// </summary>
        public static Flow? FromMicrolitersPerMinute(int? microlitersperminute)
        {
            if (microlitersperminute.HasValue)
            {
                return FromMicrolitersPerMinute(microlitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable MicrolitersPerMinute.
        /// </summary>
        public static Flow? FromMicrolitersPerMinute(long? microlitersperminute)
        {
            if (microlitersperminute.HasValue)
            {
                return FromMicrolitersPerMinute(microlitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from MicrolitersPerMinute of type decimal.
        /// </summary>
        public static Flow? FromMicrolitersPerMinute(decimal? microlitersperminute)
        {
            if (microlitersperminute.HasValue)
            {
                return FromMicrolitersPerMinute(microlitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable MillilitersPerMinute.
        /// </summary>
        public static Flow? FromMillilitersPerMinute(double? millilitersperminute)
        {
            if (millilitersperminute.HasValue)
            {
                return FromMillilitersPerMinute(millilitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable MillilitersPerMinute.
        /// </summary>
        public static Flow? FromMillilitersPerMinute(int? millilitersperminute)
        {
            if (millilitersperminute.HasValue)
            {
                return FromMillilitersPerMinute(millilitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable MillilitersPerMinute.
        /// </summary>
        public static Flow? FromMillilitersPerMinute(long? millilitersperminute)
        {
            if (millilitersperminute.HasValue)
            {
                return FromMillilitersPerMinute(millilitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from MillilitersPerMinute of type decimal.
        /// </summary>
        public static Flow? FromMillilitersPerMinute(decimal? millilitersperminute)
        {
            if (millilitersperminute.HasValue)
            {
                return FromMillilitersPerMinute(millilitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable MillionUsGallonsPerDay.
        /// </summary>
        public static Flow? FromMillionUsGallonsPerDay(double? millionusgallonsperday)
        {
            if (millionusgallonsperday.HasValue)
            {
                return FromMillionUsGallonsPerDay(millionusgallonsperday.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable MillionUsGallonsPerDay.
        /// </summary>
        public static Flow? FromMillionUsGallonsPerDay(int? millionusgallonsperday)
        {
            if (millionusgallonsperday.HasValue)
            {
                return FromMillionUsGallonsPerDay(millionusgallonsperday.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable MillionUsGallonsPerDay.
        /// </summary>
        public static Flow? FromMillionUsGallonsPerDay(long? millionusgallonsperday)
        {
            if (millionusgallonsperday.HasValue)
            {
                return FromMillionUsGallonsPerDay(millionusgallonsperday.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from MillionUsGallonsPerDay of type decimal.
        /// </summary>
        public static Flow? FromMillionUsGallonsPerDay(decimal? millionusgallonsperday)
        {
            if (millionusgallonsperday.HasValue)
            {
                return FromMillionUsGallonsPerDay(millionusgallonsperday.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable NanolitersPerMinute.
        /// </summary>
        public static Flow? FromNanolitersPerMinute(double? nanolitersperminute)
        {
            if (nanolitersperminute.HasValue)
            {
                return FromNanolitersPerMinute(nanolitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable NanolitersPerMinute.
        /// </summary>
        public static Flow? FromNanolitersPerMinute(int? nanolitersperminute)
        {
            if (nanolitersperminute.HasValue)
            {
                return FromNanolitersPerMinute(nanolitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable NanolitersPerMinute.
        /// </summary>
        public static Flow? FromNanolitersPerMinute(long? nanolitersperminute)
        {
            if (nanolitersperminute.HasValue)
            {
                return FromNanolitersPerMinute(nanolitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from NanolitersPerMinute of type decimal.
        /// </summary>
        public static Flow? FromNanolitersPerMinute(decimal? nanolitersperminute)
        {
            if (nanolitersperminute.HasValue)
            {
                return FromNanolitersPerMinute(nanolitersperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable OilBarrelsPerDay.
        /// </summary>
        public static Flow? FromOilBarrelsPerDay(double? oilbarrelsperday)
        {
            if (oilbarrelsperday.HasValue)
            {
                return FromOilBarrelsPerDay(oilbarrelsperday.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable OilBarrelsPerDay.
        /// </summary>
        public static Flow? FromOilBarrelsPerDay(int? oilbarrelsperday)
        {
            if (oilbarrelsperday.HasValue)
            {
                return FromOilBarrelsPerDay(oilbarrelsperday.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable OilBarrelsPerDay.
        /// </summary>
        public static Flow? FromOilBarrelsPerDay(long? oilbarrelsperday)
        {
            if (oilbarrelsperday.HasValue)
            {
                return FromOilBarrelsPerDay(oilbarrelsperday.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from OilBarrelsPerDay of type decimal.
        /// </summary>
        public static Flow? FromOilBarrelsPerDay(decimal? oilbarrelsperday)
        {
            if (oilbarrelsperday.HasValue)
            {
                return FromOilBarrelsPerDay(oilbarrelsperday.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable UsGallonsPerMinute.
        /// </summary>
        public static Flow? FromUsGallonsPerMinute(double? usgallonsperminute)
        {
            if (usgallonsperminute.HasValue)
            {
                return FromUsGallonsPerMinute(usgallonsperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable UsGallonsPerMinute.
        /// </summary>
        public static Flow? FromUsGallonsPerMinute(int? usgallonsperminute)
        {
            if (usgallonsperminute.HasValue)
            {
                return FromUsGallonsPerMinute(usgallonsperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from nullable UsGallonsPerMinute.
        /// </summary>
        public static Flow? FromUsGallonsPerMinute(long? usgallonsperminute)
        {
            if (usgallonsperminute.HasValue)
            {
                return FromUsGallonsPerMinute(usgallonsperminute.Value);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        ///     Get nullable Flow from UsGallonsPerMinute of type decimal.
        /// </summary>
        public static Flow? FromUsGallonsPerMinute(decimal? usgallonsperminute)
        {
            if (usgallonsperminute.HasValue)
            {
                return FromUsGallonsPerMinute(usgallonsperminute.Value);
            }
            else
            {
                return null;
            }
        }

#endif

        /// <summary>
        ///     Dynamically convert from value and unit enum <see cref="FlowUnit" /> to <see cref="Flow" />.
        /// </summary>
        /// <param name="val">Value to convert from.</param>
        /// <param name="fromUnit">Unit to convert from.</param>
        /// <returns>Flow unit value.</returns>
        public static Flow From(double val, FlowUnit fromUnit)
        {
            switch (fromUnit)
            {
                case FlowUnit.CentilitersPerMinute:
                    return FromCentilitersPerMinute(val);
                case FlowUnit.CubicDecimeterPerMinute:
                    return FromCubicDecimetersPerMinute(val);
                case FlowUnit.CubicFootPerHour:
                    return FromCubicFeetPerHour(val);
                case FlowUnit.CubicFootPerSecond:
                    return FromCubicFeetPerSecond(val);
                case FlowUnit.CubicMeterPerHour:
                    return FromCubicMetersPerHour(val);
                case FlowUnit.CubicMeterPerSecond:
                    return FromCubicMetersPerSecond(val);
                case FlowUnit.DecilitersPerMinute:
                    return FromDecilitersPerMinute(val);
                case FlowUnit.KilolitersPerMinute:
                    return FromKilolitersPerMinute(val);
                case FlowUnit.LitersPerHour:
                    return FromLitersPerHour(val);
                case FlowUnit.LitersPerMinute:
                    return FromLitersPerMinute(val);
                case FlowUnit.LitersPerSecond:
                    return FromLitersPerSecond(val);
                case FlowUnit.MicrolitersPerMinute:
                    return FromMicrolitersPerMinute(val);
                case FlowUnit.MillilitersPerMinute:
                    return FromMillilitersPerMinute(val);
                case FlowUnit.MillionUsGallonsPerDay:
                    return FromMillionUsGallonsPerDay(val);
                case FlowUnit.NanolitersPerMinute:
                    return FromNanolitersPerMinute(val);
                case FlowUnit.OilBarrelsPerDay:
                    return FromOilBarrelsPerDay(val);
                case FlowUnit.UsGallonsPerMinute:
                    return FromUsGallonsPerMinute(val);

                default:
                    throw new NotImplementedException("fromUnit: " + fromUnit);
            }
        }

        // Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx
#if !WINDOWS_UWP
        /// <summary>
        ///     Dynamically convert from value and unit enum <see cref="FlowUnit" /> to <see cref="Flow" />.
        /// </summary>
        /// <param name="value">Value to convert from.</param>
        /// <param name="fromUnit">Unit to convert from.</param>
        /// <returns>Flow unit value.</returns>
        public static Flow? From(double? value, FlowUnit fromUnit)
        {
            if (!value.HasValue)
            {
                return null;
            }
            switch (fromUnit)
            {
                case FlowUnit.CentilitersPerMinute:
                    return FromCentilitersPerMinute(value.Value);
                case FlowUnit.CubicDecimeterPerMinute:
                    return FromCubicDecimetersPerMinute(value.Value);
                case FlowUnit.CubicFootPerHour:
                    return FromCubicFeetPerHour(value.Value);
                case FlowUnit.CubicFootPerSecond:
                    return FromCubicFeetPerSecond(value.Value);
                case FlowUnit.CubicMeterPerHour:
                    return FromCubicMetersPerHour(value.Value);
                case FlowUnit.CubicMeterPerSecond:
                    return FromCubicMetersPerSecond(value.Value);
                case FlowUnit.DecilitersPerMinute:
                    return FromDecilitersPerMinute(value.Value);
                case FlowUnit.KilolitersPerMinute:
                    return FromKilolitersPerMinute(value.Value);
                case FlowUnit.LitersPerHour:
                    return FromLitersPerHour(value.Value);
                case FlowUnit.LitersPerMinute:
                    return FromLitersPerMinute(value.Value);
                case FlowUnit.LitersPerSecond:
                    return FromLitersPerSecond(value.Value);
                case FlowUnit.MicrolitersPerMinute:
                    return FromMicrolitersPerMinute(value.Value);
                case FlowUnit.MillilitersPerMinute:
                    return FromMillilitersPerMinute(value.Value);
                case FlowUnit.MillionUsGallonsPerDay:
                    return FromMillionUsGallonsPerDay(value.Value);
                case FlowUnit.NanolitersPerMinute:
                    return FromNanolitersPerMinute(value.Value);
                case FlowUnit.OilBarrelsPerDay:
                    return FromOilBarrelsPerDay(value.Value);
                case FlowUnit.UsGallonsPerMinute:
                    return FromUsGallonsPerMinute(value.Value);

                default:
                    throw new NotImplementedException("fromUnit: " + fromUnit);
            }
        }
#endif

        /// <summary>
        ///     Get unit abbreviation string.
        /// </summary>
        /// <param name="unit">Unit to get abbreviation for.</param>
        /// <returns>Unit abbreviation string.</returns>
        [UsedImplicitly]
        public static string GetAbbreviation(FlowUnit unit)
        {
            return GetAbbreviation(unit, null);
        }

        /// <summary>
        ///     Get unit abbreviation string.
        /// </summary>
        /// <param name="unit">Unit to get abbreviation for.</param>
        /// <param name="culture">Culture to use for localization. Defaults to Thread.CurrentUICulture.</param>
        /// <returns>Unit abbreviation string.</returns>
        [UsedImplicitly]
        public static string GetAbbreviation(FlowUnit unit, [CanBeNull] Culture culture)
        {
            return UnitSystem.GetCached(culture).GetDefaultAbbreviation(unit);
        }

        #endregion

        #region Arithmetic Operators

        // Windows Runtime Component does not allow operator overloads: https://msdn.microsoft.com/en-us/library/br230301.aspx
#if !WINDOWS_UWP
        public static Flow operator -(Flow right)
        {
            return new Flow(-right._cubicMetersPerSecond);
        }

        public static Flow operator +(Flow left, Flow right)
        {
            return new Flow(left._cubicMetersPerSecond + right._cubicMetersPerSecond);
        }

        public static Flow operator -(Flow left, Flow right)
        {
            return new Flow(left._cubicMetersPerSecond - right._cubicMetersPerSecond);
        }

        public static Flow operator *(double left, Flow right)
        {
            return new Flow(left*right._cubicMetersPerSecond);
        }

        public static Flow operator *(Flow left, double right)
        {
            return new Flow(left._cubicMetersPerSecond*(double)right);
        }

        public static Flow operator /(Flow left, double right)
        {
            return new Flow(left._cubicMetersPerSecond/(double)right);
        }

        public static double operator /(Flow left, Flow right)
        {
            return Convert.ToDouble(left._cubicMetersPerSecond/right._cubicMetersPerSecond);
        }
#endif

        #endregion

        #region Equality / IComparable

        public int CompareTo(object obj)
        {
            if (obj == null) throw new ArgumentNullException("obj");
            if (!(obj is Flow)) throw new ArgumentException("Expected type Flow.", "obj");
            return CompareTo((Flow) obj);
        }

        // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods
#if WINDOWS_UWP
        internal
#else
        public
#endif
        int CompareTo(Flow other)
        {
            return _cubicMetersPerSecond.CompareTo(other._cubicMetersPerSecond);
        }

        // Windows Runtime Component does not allow operator overloads: https://msdn.microsoft.com/en-us/library/br230301.aspx
#if !WINDOWS_UWP
        public static bool operator <=(Flow left, Flow right)
        {
            return left._cubicMetersPerSecond <= right._cubicMetersPerSecond;
        }

        public static bool operator >=(Flow left, Flow right)
        {
            return left._cubicMetersPerSecond >= right._cubicMetersPerSecond;
        }

        public static bool operator <(Flow left, Flow right)
        {
            return left._cubicMetersPerSecond < right._cubicMetersPerSecond;
        }

        public static bool operator >(Flow left, Flow right)
        {
            return left._cubicMetersPerSecond > right._cubicMetersPerSecond;
        }

        public static bool operator ==(Flow left, Flow right)
        {
            // ReSharper disable once CompareOfFloatsByEqualityOperator
            return left._cubicMetersPerSecond == right._cubicMetersPerSecond;
        }

        public static bool operator !=(Flow left, Flow right)
        {
            // ReSharper disable once CompareOfFloatsByEqualityOperator
            return left._cubicMetersPerSecond != right._cubicMetersPerSecond;
        }
#endif

        public override bool Equals(object obj)
        {
            if (obj == null || GetType() != obj.GetType())
            {
                return false;
            }

            return _cubicMetersPerSecond.Equals(((Flow) obj)._cubicMetersPerSecond);
        }

        public override int GetHashCode()
        {
            return _cubicMetersPerSecond.GetHashCode();
        }

        #endregion

        #region Conversion

        /// <summary>
        ///     Convert to the unit representation <paramref name="unit" />.
        /// </summary>
        /// <returns>Value in new unit if successful, exception otherwise.</returns>
        /// <exception cref="NotImplementedException">If conversion was not successful.</exception>
        public double As(FlowUnit unit)
        {
            switch (unit)
            {
                case FlowUnit.CentilitersPerMinute:
                    return CentilitersPerMinute;
                case FlowUnit.CubicDecimeterPerMinute:
                    return CubicDecimetersPerMinute;
                case FlowUnit.CubicFootPerHour:
                    return CubicFeetPerHour;
                case FlowUnit.CubicFootPerSecond:
                    return CubicFeetPerSecond;
                case FlowUnit.CubicMeterPerHour:
                    return CubicMetersPerHour;
                case FlowUnit.CubicMeterPerSecond:
                    return CubicMetersPerSecond;
                case FlowUnit.DecilitersPerMinute:
                    return DecilitersPerMinute;
                case FlowUnit.KilolitersPerMinute:
                    return KilolitersPerMinute;
                case FlowUnit.LitersPerHour:
                    return LitersPerHour;
                case FlowUnit.LitersPerMinute:
                    return LitersPerMinute;
                case FlowUnit.LitersPerSecond:
                    return LitersPerSecond;
                case FlowUnit.MicrolitersPerMinute:
                    return MicrolitersPerMinute;
                case FlowUnit.MillilitersPerMinute:
                    return MillilitersPerMinute;
                case FlowUnit.MillionUsGallonsPerDay:
                    return MillionUsGallonsPerDay;
                case FlowUnit.NanolitersPerMinute:
                    return NanolitersPerMinute;
                case FlowUnit.OilBarrelsPerDay:
                    return OilBarrelsPerDay;
                case FlowUnit.UsGallonsPerMinute:
                    return UsGallonsPerMinute;

                default:
                    throw new NotImplementedException("unit: " + unit);
            }
        }

        #endregion

        #region Parsing

        /// <summary>
        ///     Parse a string with one or two quantities of the format "<quantity> <unit>".
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <example>
        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="ArgumentException">
        ///     Expected string to have one or two pairs of quantity and unit in the format
        ///     "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in"
        /// </exception>
        /// <exception cref="AmbiguousUnitParseException">
        ///     More than one unit is represented by the specified unit abbreviation.
        ///     Example: Volume.Parse("1 cup") will throw, because it can refer to any of
        ///     <see cref="VolumeUnit.MetricCup" />, <see cref="VolumeUnit.UsLegalCup" /> and <see cref="VolumeUnit.UsCustomaryCup" />.
        /// </exception>
        /// <exception cref="UnitsNetException">
        ///     If anything else goes wrong, typically due to a bug or unhandled case.
        ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
        ///     Units.NET exceptions from other exceptions.
        /// </exception>
        public static Flow Parse(string str)
        {
            return Parse(str, null);
        }

        /// <summary>
        ///     Parse a string with one or two quantities of the format "<quantity> <unit>".
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <param name="culture">Format to use when parsing number and unit. If it is null, it defaults to <see cref="NumberFormatInfo.CurrentInfo"/> for parsing the number and <see cref="CultureInfo.CurrentUICulture"/> for parsing the unit abbreviation by culture/language.</param>
        /// <example>
        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="ArgumentException">
        ///     Expected string to have one or two pairs of quantity and unit in the format
        ///     "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in"
        /// </exception>
        /// <exception cref="AmbiguousUnitParseException">
        ///     More than one unit is represented by the specified unit abbreviation.
        ///     Example: Volume.Parse("1 cup") will throw, because it can refer to any of
        ///     <see cref="VolumeUnit.MetricCup" />, <see cref="VolumeUnit.UsLegalCup" /> and <see cref="VolumeUnit.UsCustomaryCup" />.
        /// </exception>
        /// <exception cref="UnitsNetException">
        ///     If anything else goes wrong, typically due to a bug or unhandled case.
        ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
        ///     Units.NET exceptions from other exceptions.
        /// </exception>
        public static Flow Parse(string str, [CanBeNull] Culture culture)
        {
            if (str == null) throw new ArgumentNullException("str");

        // Windows Runtime Component does not support CultureInfo type, so use culture name string for public methods instead: https://msdn.microsoft.com/en-us/library/br230301.aspx
#if WINDOWS_UWP
            IFormatProvider formatProvider = culture == null ? null : new CultureInfo(culture);
#else
            IFormatProvider formatProvider = culture;
#endif
            return QuantityParser.Parse<Flow, FlowUnit>(str, formatProvider,
                delegate(string value, string unit, IFormatProvider formatProvider2)
                {
                    double parsedValue = double.Parse(value, formatProvider2);
                    FlowUnit parsedUnit = ParseUnit(unit, formatProvider2);
                    return From(parsedValue, parsedUnit);
                }, (x, y) => FromCubicMetersPerSecond(x.CubicMetersPerSecond + y.CubicMetersPerSecond));
        }

        /// <summary>
        ///     Try to parse a string with one or two quantities of the format "<quantity> <unit>".
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <param name="result">Resulting unit quantity if successful.</param>
        /// <example>
        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
        /// </example>
        public static bool TryParse([CanBeNull] string str, out Flow result)
        {
            return TryParse(str, null, out result);
        }

        /// <summary>
        ///     Try to parse a string with one or two quantities of the format "<quantity> <unit>".
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <param name="culture">Format to use when parsing number and unit. If it is null, it defaults to <see cref="NumberFormatInfo.CurrentInfo"/> for parsing the number and <see cref="CultureInfo.CurrentUICulture"/> for parsing the unit abbreviation by culture/language.</param>
        /// <param name="result">Resulting unit quantity if successful.</param>
        /// <example>
        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
        /// </example>
        public static bool TryParse([CanBeNull] string str, [CanBeNull] Culture culture, out Flow result)
        {
            try
            {
                result = Parse(str, culture);
                return true;
            }
            catch
            {
                result = default(Flow);
                return false;
            }
        }

        /// <summary>
        ///     Parse a unit string.
        /// </summary>
        /// <example>
        ///     Length.ParseUnit("m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="UnitsNetException">Error parsing string.</exception>
        public static FlowUnit ParseUnit(string str)
        {
            return ParseUnit(str, (IFormatProvider)null);
        }

        /// <summary>
        ///     Parse a unit string.
        /// </summary>
        /// <example>
        ///     Length.ParseUnit("m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="UnitsNetException">Error parsing string.</exception>
        public static FlowUnit ParseUnit(string str, [CanBeNull] string cultureName)
        {
            return ParseUnit(str, cultureName == null ? null : new CultureInfo(cultureName));
        }

        /// <summary>
        ///     Parse a unit string.
        /// </summary>
        /// <example>
        ///     Length.ParseUnit("m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="UnitsNetException">Error parsing string.</exception>

        // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods
#if WINDOWS_UWP
        internal
#else
        public
#endif
        static FlowUnit ParseUnit(string str, IFormatProvider formatProvider = null)
        {
            if (str == null) throw new ArgumentNullException("str");

            var unitSystem = UnitSystem.GetCached(formatProvider);
            var unit = unitSystem.Parse<FlowUnit>(str.Trim());

            if (unit == FlowUnit.Undefined)
            {
                var newEx = new UnitsNetException("Error parsing string. The unit is not a recognized FlowUnit.");
                newEx.Data["input"] = str;
                newEx.Data["formatprovider"] = formatProvider?.ToString() ?? "(null)";
                throw newEx;
            }

            return unit;
        }

        #endregion

        /// <summary>
        ///     Set the default unit used by ToString(). Default is CubicMeterPerSecond
        /// </summary>
        public static FlowUnit ToStringDefaultUnit { get; set; } = FlowUnit.CubicMeterPerSecond;

        /// <summary>
        ///     Get default string representation of value and unit.
        /// </summary>
        /// <returns>String representation.</returns>
        public override string ToString()
        {
            return ToString(ToStringDefaultUnit);
        }

        /// <summary>
        ///     Get string representation of value and unit. Using current UI culture and two significant digits after radix.
        /// </summary>
        /// <param name="unit">Unit representation to use.</param>
        /// <returns>String representation.</returns>
        public string ToString(FlowUnit unit)
        {
            return ToString(unit, null, 2);
        }

        /// <summary>
        ///     Get string representation of value and unit. Using two significant digits after radix.
        /// </summary>
        /// <param name="unit">Unit representation to use.</param>
        /// <param name="culture">Culture to use for localization and number formatting.</param>
        /// <returns>String representation.</returns>
        public string ToString(FlowUnit unit, [CanBeNull] Culture culture)
        {
            return ToString(unit, culture, 2);
        }

        /// <summary>
        ///     Get string representation of value and unit.
        /// </summary>
        /// <param name="unit">Unit representation to use.</param>
        /// <param name="culture">Culture to use for localization and number formatting.</param>
        /// <param name="significantDigitsAfterRadix">The number of significant digits after the radix point.</param>
        /// <returns>String representation.</returns>
        [UsedImplicitly]
        public string ToString(FlowUnit unit, [CanBeNull] Culture culture, int significantDigitsAfterRadix)
        {
            double value = As(unit);
            string format = UnitFormatter.GetFormat(value, significantDigitsAfterRadix);
            return ToString(unit, culture, format);
        }

        /// <summary>
        ///     Get string representation of value and unit.
        /// </summary>
        /// <param name="culture">Culture to use for localization and number formatting.</param>
        /// <param name="unit">Unit representation to use.</param>
        /// <param name="format">String format to use. Default:  "{0:0.##} {1} for value and unit abbreviation respectively."</param>
        /// <param name="args">Arguments for string format. Value and unit are implictly included as arguments 0 and 1.</param>
        /// <returns>String representation.</returns>
        [UsedImplicitly]
        public string ToString(FlowUnit unit, [CanBeNull] Culture culture, [NotNull] string format,
            [NotNull] params object[] args)
        {
            if (format == null) throw new ArgumentNullException(nameof(format));
            if (args == null) throw new ArgumentNullException(nameof(args));

        // Windows Runtime Component does not support CultureInfo type, so use culture name string for public methods instead: https://msdn.microsoft.com/en-us/library/br230301.aspx
#if WINDOWS_UWP
            IFormatProvider formatProvider = culture == null ? null : new CultureInfo(culture);
#else
            IFormatProvider formatProvider = culture;
#endif
            double value = As(unit);
            object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, formatProvider, args);
            return string.Format(formatProvider, format, formatArgs);
        }

        /// <summary>
        /// Represents the largest possible value of Flow
        /// </summary>
        public static Flow MaxValue
        {
            get
            {
                return new Flow(double.MaxValue);
            }
        }

        /// <summary>
        /// Represents the smallest possible value of Flow
        /// </summary>
        public static Flow MinValue
        {
            get
            {
                return new Flow(double.MinValue);
            }
        }
    }
}


text:
<!doctype html>
<title>{% block title %}Welcome{% endblock %} | OpenID Example</title>
<link rel=stylesheet type=text/css href="{{ url_for('static',
  filename='style.css') }}">

 OpenID Example

  {% if g.user %}

sign out
  {% else %}

sign in
  {% endif %}

{% for message in get_flashed_messages() %}

{{ message }}
{% endfor %}
{% block body %}{% endblock %}

redpajama_set_name: RedPajamaGithub