bulk acrolinx fixes

Author: Tyler Whitney

docs/c-runtime-library/inp-inpw-inpd.md

@@ -39,7 +39,7 @@ I/O port number.
 
 ## Return Value
 
-The functions return the byte, word, or double word read from `port`. There is no error return.
+The functions return the byte, word, or double word read from `port`. There's no error return.
 
 ## Remarks
 

docs/c-runtime-library/reference/abs-labs-llabs-abs64.md

@@ -38,7 +38,7 @@ Numeric value.
 
 ## Return Value
 
-The **abs**, **labs**, **llabs** and **_abs64** functions return the absolute value of the parameter *n*. There is no error return.
+The **abs**, **labs**, **llabs**, and **_abs64** functions return the absolute value of the parameter *n*. There's no error return.
 
 ## Remarks
 

docs/c-runtime-library/reference/acos-acosf-acosl.md

@@ -45,7 +45,7 @@ By default, if *x* is less than -1 or greater than 1, **acos** returns an indefi
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **acos** that take and return **`float`** and **`long double`** types. In a C program, unless you are using the \<tgmath.h> macro to call this function, **acos** always takes and returns a **`double`**.
+Because C++ allows overloading, you can call overloads of **acos** that take and return **`float`** and **`long double`** types. In a C program, unless you're using the \<tgmath.h> macro to call this function, **acos** always takes and returns a **`double`**.
 
 If you use the \<tgmath.h> `acos()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/acosh-acoshf-acoshl.md

@@ -42,7 +42,7 @@ The **acosh** functions return the inverse hyberbolic cosine (arc hyperbolic cos
 
 ## Remarks
 
-When you use C++, you can call overloads of **acosh** that take and return **`float`** or **`long double`** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **acosh** always takes and returns **`double`**.
+When you use C++, you can call overloads of **acosh** that take and return **`float`** or **`long double`** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **acosh** always takes and returns **`double`**.
 
 If you use the \<tgmath.h> `acosh()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/asin-asinf-asinl.md

@@ -45,7 +45,7 @@ By default, if *x* is less than -1 or greater than 1, **asin** returns an indefi
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **asin** with **`float`** and **`long double`** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **asin** always takes and returns a **`double`**.
+Because C++ allows overloading, you can call overloads of **asin** with **`float`** and **`long double`** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **asin** always takes and returns a **`double`**.
 
 If you use the \<tgmath.h> `asin()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/asinh-asinhf-asinhl.md

@@ -41,7 +41,7 @@ The **asinh** functions return the inverse hyberbolic sine (arc hyperbolic sine)
 
 ## Remarks
 
-When you use C++, you can call overloads of **asinh** that take and return **`float`** or **`long double`** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **asinh** always takes and returns **`double`**.
+When you use C++, you can call overloads of **asinh** that take and return **`float`** or **`long double`** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **asinh** always takes and returns **`double`**.
 
 If you use the \<tgmath.h> `asinh()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/atan-atanf-atanl-atan2-atan2f-atan2l.md

@@ -57,7 +57,7 @@ If you use the \<tgmath.h> `atan()` or `atan2()` macro, the type of the argument
 
 **atan** has an implementation that uses Streaming SIMD Extensions 2 (SSE2). For information and restrictions about using the SSE2 implementation, see [_set_SSE2_enable](set-sse2-enable.md).
 
-Because C++ allows overloading, you can call overloads of **atan** and **atan2** that take **`float`** or **`long double`** arguments. In a C program, unless you are using the \<tgmath.h> macro to call this function, **atan** and **atan2** always take **`double`** arguments and return a **`double`**.
+Because C++ allows overloading, you can call overloads of **atan** and **atan2** that take **`float`** or **`long double`** arguments. In a C program, unless you're using the \<tgmath.h> macro to call this function, **atan** and **atan2** always take **`double`** arguments and return a **`double`**.
 
 By default, this function's global state is scoped to the application. To change this, see [Global state in the CRT](../global-state.md).
 

docs/c-runtime-library/reference/atanh-atanhf-atanhl.md

@@ -42,7 +42,7 @@ The **atanh** functions return the inverse hyberbolic tangent (arc hyperbolic ta
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **atanh** that take and return **`float`** or **`long double`** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **atanh** always takes and returns **`double`**.
+Because C++ allows overloading, you can call overloads of **atanh** that take and return **`float`** or **`long double`** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **atanh** always takes and returns **`double`**.
 
 If you use the \<tgmath.h> `atanh()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/carg-cargf-cargl.md

@@ -46,7 +46,7 @@ The argument (also known as the phase) of *z*. The result is in the interval [-
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **carg** that take **_Fcomplex** or **_Lcomplex** values, and return **`float`** or **`long double`** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **carg** always takes a **_Dcomplex** value and returns a **`double`** value.
+Because C++ allows overloading, you can call overloads of **carg** that take **_Fcomplex** or **_Lcomplex** values, and return **`float`** or **`long double`** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **carg** always takes a **_Dcomplex** value and returns a **`double`** value.
 
 If you use the \<tgmath.h> `carg()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/cbrt-cbrtf-cbrtl.md

@@ -50,7 +50,7 @@ The **cbrt** functions return the cube-root of *x*.
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **cbrt** that take **`float`** or **`long double`** types. In a C program, unless you are using the \<tgmath.h> macro to call this function, **cbrt** always takes and returns **`double`**.
+Because C++ allows overloading, you can call overloads of **cbrt** that take **`float`** or **`long double`** types. In a C program, unless you're using the \<tgmath.h> macro to call this function, **cbrt** always takes and returns **`double`**.
 
 If you use the \<tgmath.h> `cbrt()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/ceil-ceilf-ceill.md

@@ -42,7 +42,7 @@ Floating-point value.
 
 ## Return Value
 
-The **ceil** functions return a floating-point value that represents the smallest integer that is greater than or equal to *x*. There is no error return.
+The **ceil** functions return a floating-point value that represents the smallest integer that is greater than or equal to *x*. There's no error return.
 
 |Input|SEH Exception|Matherr Exception|
 |-----------|-------------------|-----------------------|
@@ -52,7 +52,7 @@ The **ceil** functions return a floating-point value that represents the smalles
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **ceil** that take **`float`** or **`long double`** types. In a C program, unless you are using the \<tgmath.h> macro to call this function, **ceil** always takes and returns a **`double`**.
+Because C++ allows overloading, you can call overloads of **ceil** that take **`float`** or **`long double`** types. In a C program, unless you're using the \<tgmath.h> macro to call this function, **ceil** always takes and returns a **`double`**.
 
 f you use the <tgmath.h> `ceil()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/chgsign-chgsignf-chgsignl.md

@@ -34,7 +34,7 @@ The floating-point value to be changed.
 
 ## Return Value
 
-The **_chgsign** functions return a value that's equal to the floating-point argument *x*, but with its sign reversed. There is no error return.
+The **_chgsign** functions return a value that's equal to the floating-point argument *x*, but with its sign reversed. There's no error return.
 
 ## Requirements
 

docs/c-runtime-library/reference/cimag-cimagf-cimagl.md

@@ -37,7 +37,7 @@ The imaginary part of *z*.
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **cimag** that take **_Fcomplex** or **_Lcomplex** values, and return **`float`** or **`long double`** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **cimag** always takes a **_Dcomplex** value and returns a **`double`** value.
+Because C++ allows overloading, you can call overloads of **cimag** that take **_Fcomplex** or **_Lcomplex** values, and return **`float`** or **`long double`** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **cimag** always takes a **_Dcomplex** value and returns a **`double`** value.
 
 If you use the \<tgmath.h> `cimag()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/conj-conjf-conjl.md

@@ -46,7 +46,7 @@ The complex conjugate  of *z*.  The result has the same real and imaginary part
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **conj** that take and return **_Fcomplex** and **_Lcomplex** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **conj** always takes and returns a **_Dcomplex** value.
+Because C++ allows overloading, you can call overloads of **conj** that take and return **_Fcomplex** and **_Lcomplex** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **conj** always takes and returns a **_Dcomplex** value.
 
 If you use the \<tgmath.h> `conj()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/copysign-copysignf-copysignl-copysign-copysignf-copysignl.md

@@ -60,11 +60,11 @@ The floating-point value that's returned as the sign of the result.
 
 ## Return Value
 
-The **copysign** functions return a floating-point value that combines the magnitude of *x* and the sign of *y*. There is no error return.
+The **copysign** functions return a floating-point value that combines the magnitude of *x* and the sign of *y*. There's no error return.
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **copysign** that take and return **`float`** or **`long double`** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **copysign** always takes and returns a **`double`**.
+Because C++ allows overloading, you can call overloads of **copysign** that take and return **`float`** or **`long double`** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **copysign** always takes and returns a **`double`**.
 
 If you use the \<tgmath.h> `copysign()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/cos-cosf-cosl.md

@@ -42,7 +42,7 @@ The cosine of *x*. If *x* is greater than or equal to 263, or less than or equal
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **cos** that take and return **`float`** or **`long double`** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **cos** always takes and returns a **`double`**.
+Because C++ allows overloading, you can call overloads of **cos** that take and return **`float`** or **`long double`** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **cos** always takes and returns a **`double`**.
 
 If you use the \<tgmath.h> `cos()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/cosh-coshf-coshl.md

@@ -43,7 +43,7 @@ By default, if the result is too large in a **cosh**, **coshf**, or **coshl** ca
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **cosh** that take and return **`float`** or **`long double`** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **cosh** always takes and returns a **`double`**.
+Because C++ allows overloading, you can call overloads of **cosh** that take and return **`float`** or **`long double`** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **cosh** always takes and returns a **`double`**.
 
 If you use the \<tgmath.h> `cosh()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/cproj-cprojf-cprojl.md

@@ -46,7 +46,7 @@ The projection of *z* on the Reimann sphere.
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **cproj** that take and return **_Fcomplex** and **_Lcomplex** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **cproj** always takes and returns a **_Dcomplex** value.
+Because C++ allows overloading, you can call overloads of **cproj** that take and return **_Fcomplex** and **_Lcomplex** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **cproj** always takes and returns a **_Dcomplex** value.
 
 If you use the \<tgmath.h> `cproj()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/creal-crealf-creall.md

@@ -37,7 +37,7 @@ The real part of *z*.
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **creal** that take **_Fcomplex** or **_Lcomplex** values, and return **`float`** or **`long double`** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **creal** always takes a **_Dcomplex** value and returns a **`double`** value.
+Because C++ allows overloading, you can call overloads of **creal** that take **_Fcomplex** or **_Lcomplex** values, and return **`float`** or **`long double`** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **creal** always takes a **_Dcomplex** value and returns a **`double`** value.
 
 If you use the \<tgmath.h> `creal()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/erf-erff-erfl-erfc-erfcf-erfcl.md

@@ -66,9 +66,9 @@ The **erf** functions calculate the Gauss error function of *x*, which is define
 
 ![The error function of x](media/crt_erf_formula.PNG "The error function of x")
 
-The complementary Gauss error function is defined as 1 - erf(x). The **erf** functions return a value in the range -1.0 to 1.0. There is no error return. The **erfc** functions return a value in the range 0 to 2. If *x* is too large for **erfc**, the **errno** variable is set to **ERANGE**.
+The complementary Gauss error function is defined as 1 - erf(x). The **erf** functions return a value in the range -1.0 to 1.0. There's no error return. The **erfc** functions return a value in the range 0 to 2. If *x* is too large for **erfc**, the **errno** variable is set to **ERANGE**.
 
-Because C++ allows overloading, you can call overloads of **erf** and **erfc** that take and return **`float`** and **`long double`** types. In a C program, unless you are using the \<tgmath.h> macro to call this function, **erf** and **erfc** always take and return a **`double`**.
+Because C++ allows overloading, you can call overloads of **erf** and **erfc** that take and return **`float`** and **`long double`** types. In a C program, unless you're using the \<tgmath.h> macro to call this function, **erf** and **erfc** always take and return a **`double`**.
 
 If you use the \<tgmath.h> `erf()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/exp-expf.md

@@ -55,7 +55,7 @@ The **exp** function has an implementation that uses Streaming SIMD Extensions 2
 
 ## Remarks
 
-C++ allows overloading, so you can call overloads of **exp** that take a **`float`** or **`long double`** argument. In a C program, unless you are using the \<tgmath.h> macro to call this function, **exp** always takes and returns a **`double`**.
+C++ allows overloading, so you can call overloads of **exp** that take a **`float`** or **`long double`** argument. In a C program, unless you're using the \<tgmath.h> macro to call this function, **exp** always takes and returns a **`double`**.
 
 If you use the \<tgmath.h> `exp()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/exp2-exp2f-exp2l.md

@@ -61,7 +61,7 @@ Errors are reported as specified in [_matherr](matherr.md).
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **exp2** that take and return **`float`** and **`long double`** types. In a C program, unless you are using the \<tgmath.h> macro to call this function, **exp2** always takes and returns a **`double`**, unless you use the macro in <tgmath.h>.
+Because C++ allows overloading, you can call overloads of **exp2** that take and return **`float`** and **`long double`** types. In a C program, unless you're using the \<tgmath.h> macro to call this function, **exp2** always takes and returns a **`double`**, unless you use the macro in <tgmath.h>.
 
 If you use the \<tgmath.h> `exp2()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/expm1-expm1f-expm1l.md

@@ -46,7 +46,7 @@ The **expm1** functions return a floating-point value that represents e<sup>x</s
 
 ## Remarks
 
-Because C++ allows overloading, you can call overloads of **expm1** that take and return **`float`** and **`long double`** values. In a C program, unless you are using the \<tgmath.h> macro to call this function, **expm1** always takes and returns a **`double`**.
+Because C++ allows overloading, you can call overloads of **expm1** that take and return **`float`** and **`long double`** values. In a C program, unless you're using the \<tgmath.h> macro to call this function, **expm1** always takes and returns a **`double`**.
 
 If you use the \<tgmath.h> `expm1()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.
 

docs/c-runtime-library/reference/fabs-fabsf-fabsl.md

@@ -51,7 +51,7 @@ The **fabs** functions return the absolute value of the argument *x*. There's no
 
 ## Remarks
 
-C++ allows overloading, so you can call overloads of **fabs** if you include the \<cmath> header. In a C program, unless you are using the \<tgmath.h> macro to call this function, **fabs** always takes and returns a **`double`**.
+C++ allows overloading, so you can call overloads of **fabs** if you include the \<cmath> header. In a C program, unless you're using the \<tgmath.h> macro to call this function, **fabs** always takes and returns a **`double`**.
 
 If you use the \<tgmath.h> `fabs()` macro, the type of the argument determines which version of the function is selected. See [Type-generic math](../../c-runtime-library/tgmath.md) for details.