User:Tom.Reding/JPL to Infobox planet

What this code does

edit

This C# AWB module is meant to facilitate, and reduce the error associated with, tediously transcribing data from JPL's Small-Body Database to most of WP's ~3,200 minor planet articles.

  1. General conformity: Generally tries to model itself on the lowest-numbered MPs, which are popular enough to be considered the consensus for what to display and how (after looking at a subset of 15-25 of them). If I have mischaracterized something, please bring it up on this page's talk page.
    1. Uses {{Convert|value|AU|km/Gm/Tm}} with |aphelion=,(abbr=on) |semimajor=, |perihelion=, |moid=, & |jupiter_moid=.
    2. Uses {{val|value|error}} when error is known for |rotation=, |albedo=, |mean_radius=, & |abs_magnitude=, otherwise uses the bare value.
    3. If |background= != 3-6-digit hexidecimal or does not exist, then make/add default |background=#FFFFC0 (see User:Rfassbind/sandbox/color-scheme).
  2. Spacing conformity & standardization:
    1. Maintains the existing spacing format of the infobox before and after | and = characters, based on most existing, non-empty parameters (up to 108 out of 114, and the most frequent usage wins).
    2. If 3 or more spaces exist before the =, it's assumed that some form of =-alignment is being used, so h-alignment is maintained.
    3. 2 or more spaces after the = are assumed to be typos and are truncated to 1.
    4. If one of the 3 |*_ref= parameters start with  , adds   to the other 2, if they're not empty.
    5. If &thinsp; is used > 40% of the time that it could have been used between values and <ref>/{{efn}}s, then apply it 100% of the time, including headings (|*_ref=s).
    6. Unicode tabs are replaced with a single space prior to whitespace standardization.
  3. Standardization/Formatting/Cleanup:
    1. Appends/adds a JPL ref to |orbit_ref=, if no ref names in that parameter contain "jpl|sbdb|orbit" (case insensitive) nor possess a JPL URL. If a "jpl" ref name doesn't exist in the article, nor a named ref with a JPL URL, adds a full ref named "jpldata" to |orbit_ref=; otherwise, the 1st ref containing "jpl|sbdb|orbit" or JPL URL is used, in that order.
    2. Fills in "bare" JPL & Lowell FTP refs anywhere.
    3. Replace unnamed {{Cite SBDB}} refs with master <ref name="jpldata">{{Cite web|...}}, which is modeled after {{Cite SBDB}}.
    4. Ref-wrap any bare URL in |orbit_ref=.
    5. Removes deprecated parameters (listed below).
    6. Corrects {{Infobox planet}} aliases to {{Infobox planet.
    7. Moves end-of-line | to the next line.
    8. Moves parameters on the "{{Infobox planet" line to the next line.
    9. Moves multiple infobox-parameters (in-line citation-parameters are untouched) on the same line to multiple lines.
    10. If 1 OE parameter contains a symbol ((Ω), (M), etc.) symbols will be added to/maintained on all other OE params.
    11. Moves |mean_radius= under |dimensions= for easier checking.
    12. Moves text between last <ref>/{{efn}}/{{Cite SBDB}} and EndOfLine to before.
    13. Moves lines starting with <ref or </ref up to the end of the previous line.
    14. Removes lines that don't start with |, {{, or }}, with/out leading whitespace.
    15. Removes parameter-description comments from non-empty parameters.
    16. Removes redundant JPL link in ==External links==.
    17. Fix mislinks to List of minor planets: 1001–2000, etc.
    18. Remove text after last <br> if a reference exists before it, but not after it.
      1. Remove text after <br> no matter what, for |period=.
  4. Precision: All modified values are also rounded. Mimics the existing infobox precision if >= 5 digits; otherwise it defaults to 5-digit precision (similar to JPL's error-precision) or the average precision of existing parameters, whichever is higher, if possible. Exceptions:
    1. |period=: Year's precision is unmodified because it is rarely (if ever) more precise than 0.01 years (3.6525 days). Day's value, which seems to be derived from years, instead of vice versa, is truncated to 0-2 decimal places, inversely proportional to the size of year (i.e. a several hundred+ year period is given an integer day value). It's tempting to ascribe 4-decimal precision to days, but multiplying an uncertain value by a very certain (or exact) value does not bestow that certainty to the result. I.e. 0.0001 days leads the reader to assume an 8.64 second precision, which is actually swimming in a 3.65 day uncertainty.
    2. JPL's MOID values are unmodified, due to not having any listed error values.
    3. |mean_motion= (new) uses {{Deg2DMS}} if < 1°.
  5. Uncertainty:
    1. Uncertainty (±) is not displayed for Orbital Elements (OE), because 1) the uncertainty is generally extremely small (MPs with low |observation_arc= might be skipped in the future, or maybe uncertainties >= 10% will be shown, haven't decided yet (needs consensus, ideally)), and 2) OE uncertainties generally don't appear in the lowest #'d MPs (see 1. General Conformity, above).
    2. When available, uncertainties are used, for: |abs_magnitude= & |albedo= since MP size is very sensitive to these values, and |mean_radius=, |dimensions=, and |rotation=.
    3. Display uncertainty for OE if they're large (>= 1, or |mean_motion= error > 1/2 the value).
  6. Updating access-date:
    1. Appends or replaces the |access-date= value with <Today's d MMMM yyyy> in the jpl/sbdb/orbit 'master' ref (excludes {{JPL small body}} & {{MPCit JPL}}).
    2. Adopts the local spacing convention when appending access-date.
  7. Accommodating existing values:
    1. Prepends JPL's value + JPL ref for |abs_magnitude=, |rotation=, |albedo=, |mean_radius=, |dimensions= if non-JPL refs exist in that parameter; otherwise updates the JPL value (assuming the ref name contains "jpl", "sbdb", or JPL URL, case insensitive).
    2. Prefers to <br />-separate different values, if ,-separation doesn't exist.
      1. Prefers ,-separation for |abs_magnitude=, since multiple values can easily render on 1 line.
  8. Skipping:
    1. Skips pages without an {{Infobox planet}} or alias (to do, low priority: allow code to build an infobox if none exist).
    2. Skips infoboxes that don't end with }} or |}} on a separate line (~8% of MP infoboxes prior to fixing).
    3. Skips pages with recently updated JPL references, based on |access-date= and user-defined month & year lists.
  9. New parameters: Appends new parameters to the bottom of the infobox, except |minor_planet=yes and |background=#FFFFC0 , which are inserted at the top, and |mean_radius=, which is inserted/moved to below |dimensions=.
  10. Scope: The following 41 {{Infobox planet}} parameters are accounted for/operated on in some way (alphabetized, () = deprecated, * = fix spacing only):
  • |abs_magnitude=
  • |albedo=
  • |aphelion=
  • |arg_peri=
  • |asc_node=
  • |atmosphere_ref=
  • |background=
  • (|bgcolour=)
  • |caption=*
  • (|designations=)
  • (|diameter=)never used
  • |dimensions=
  • |discovered=
  • (|discovery=)
  • |discovery_ref=
  • |eccentricity=
  • |epoch=
  • |inclination=
  • |jupiter_moid=
  • |label_width=
  • |mass=
  • |mean_anomaly=
  • |mean_motion=
  • |mean_radius=
  • |minorplanet=
  • |moid=
  • |mp_name=*
  • |name=*
  • |named_after=*
  • |observation_arc=
  • |orbit_ref=
  • (|orbital_characteristics=)
  • |p_orbit_ref=
  • |perihelion=
  • |period=
  • (|physical_characteristics=)
  • |rotation=
  • |semimajor=
  • |tisserand=
  • |uncertainty=
  • (|width=)

The settings file is essentially empty. The only boxes checked are Options > Apply general fixes, Skip > No changes made and Page is redirect, and Start > Minor edit.

What this code does not

edit

This is not a "set it and forget it" script.

  1. It must be babysat.
  2. It's only meant to keep obscure, infrequently edited minor planets up-to-date (i.e. best for numbered MPs > 500-1000, and more care required for those < 500).
  3. Frequently edited pages with multiple-ref infoboxes might not play well with this script (but many do).
  4. Each modified parameter-line in the infobox must be examined so that no useful information is lost nor wikisyntax broken. This is due to the large number of display-variants, which the script attempts to account for, but exceptions will always exist and they need to be spotted.
    1. Most display-variants (mutiple <ref>s (<br>-delimited or ,-delimited), multiple values with or without their measurement error, {{efn}}, {{small}}, {{val}}, {{convert}}) are accounted for for these parameters only (the most common offenders, and because you're not allowed to make custom classes in AWB): |abs_magnitude=, |rotation=, |albedo=, |mean_radius=, |dimensions=.

  ~ Tom.Reding (talkdgaf)  17:22, 18 March 2016 (UTC)

AWB custom module

edit

(Syntax highlighting is broken because code is too long)

public string ProcessArticle(string ArticleText, string ArticleTitle, int wikiNamespace, out string Summary, out bool Skip)
{
	// global switches & vars ///////////////////////////////////////////////////
	
	// all custom switches = true by default
	bool skipMisspelledArticleTitles = true; // true to skip 16596 Stevenstrauss/Stephenstrauss, etc.
	bool skipProvisionalJPLandWPMismatches = true; // some provisional asteroids don't show up in JPL
	bool skipAlmostAllJPLandWPMismatches = true;  // any mismatch other than diacritics
	bool skipEntirePageIfAnyJPLUnitsDontMatchExpected = true;
	bool   skipIfRecentlyUpdated = true; // based on access-date in JPL ref
	string SkipIfRecentlyUpdated_InMonth = @"February, March, April, May"; // full month names; case INsensitive; commas optional; if string is empty, match any month
	string SkipIfRecentlyUpdated_InYear  = @"2016";
	
	Skip = false;
	Summary = @"Update infobox with JPL data ([[User:Tom.Reding/JPL to Infobox planet|code]])";
	string OriginalSummary = Summary; // used to catch exceptions & trigger skip-conditions in various sections
	string ArticleTitle_latin = "dummy ArticleTitle_latin"; // need non-empty dummy declares here to make vars global
	string JPL_DDate = "dummy JPL_DDate";
	string Unique_ID = "dummy Unique_ID"; // either a # (for #+name and #+prelim MPs), or prelim (for prelim MPs)
	string Param = "dummy Param";
	string RefName_jpl = "dummy RefName_jpl";
	string RefName_lowell = "dummy RefName_lowell";
	string JPLRefNameVariants = @"jpl|sbdb|orbit"; // regex
	string JPLDataRef_Master = "dummy JPLDataRef_Master";
	string JPLDataRef_MasterOrSlave = "dummy JPLDataRef_MasterOrSlave";
	string LowellRef_Master  = "dummy LowellRef_Master";
	string LowellRef_MasterOrSlave = "dummy LowellRef_MasterOrSlave";
	bool jplDataMasterExists = false;
	bool lowellMasterExists = false;
	bool areSymbolsUsed = false; // "(Ω)", "(M)", etc.
	
	string OldInfobox = "dummy OldInfobox";
	string NewInfobox = "dummy NewInfobox";
	
	// Infobox spacing variables (before & after "|" and "=", and &thinsp;<ref>)
	string S1, S2, S3, S4;
	S1 = S2 = S3 = S4 = "";
	string S12 = S1 + "|" + S2;
	int EqualAlignTo = 0;
	string ThinspRefs = ""; // populate with unicode thinsp, if necessary
	string ThinspRefs_HTML = ""; // populate with HTML &thinsp;, if necessary
	string ThinspHeadings = "";
	
	// append parameters to infobox if DNE
	Regex rAppendToInfobox = new Regex(@"(.+[\r\n]+ *)\|? *(\}\}\s)", RegexOptions.Singleline);
	
	// lists of parameters
	List<string> FrequentlyMalformedParamList = new List<string>(new string[] { "name", "mp_name", "named_after", "background", "caption", "width" }); // 6
	List<string> UpdatableParamList = new List<string>(new string[] { "abs_magnitude", "albedo", "aphelion", "arg_peri", "asc_node",
		"bgcolour", "designations", "dimensions", "discovered", "eccentricity", "epoch", "inclination", "jupiter_moid", "mass", "mean_anomaly",
		"mean_radius", "minorplanet", "moid", "observation_arc", "orbit_ref", "p_mean_motion", "perihelion", "period", "rotation",
		"semimajor", "tisserand", "uncertainty" }); // 27 of the non-deprecated params this code updates (excludes FrequentlyMalformedParamList)
	List<string> AlmostAllParamList = new List<string>(new string[] { "minorplanet", "extrasolarplanet", "symbol", "image", "image_alt",
		"discovery_ref", "discoverer", "discovery_site", "discovered", "discovery_method", "designations", "pronounced", "alt_names",
		"mp_category", "adjectives", "orbit_ref", "orbit_diagram", "epoch", "uncertainty", "observation_arc", "apsis", "aphelion",
		"perihelion", "periastron", "apoastron", "periapsis", "apoapsis", "semimajor", "mean_orbit_radius", "eccentricity", "period",
		"synodic_period", "avg_speed", "mean_anomaly", "inclination", "angular_dist", "asc_node", "long_periastron", "time_periastron",
		"arg_peri", "semi-amplitude", "satellite_of", "satellites", "moid", "mercury_moid", "venus_moid", "mars_moid", "jupiter_moid",
		"saturn_moid", "uranus_moid", "neptune_moid", "p_orbit_ref", "p_semimajor", "p_eccentricity", "p_inclination", "p_mean_motion",
		"perihelion_rate", "node_rate", "dimensions", "mean_radius", "equatorial_radius", "polar_radius", "flattening", "circumference",
		"surface_area", "volume", "mass", "density", "surface_grav", "moment_of_inertia_factor", "escape_velocity", "sidereal_day",
		"rot_velocity", "rotation", "axial_tilt", "right_asc_north_pole", "declination", "pole_ecliptic_lat", "pole_ecliptic_lon",
		"albedo", "single_temperature", "temp_name1", "min_temp_1", "mean_temp_1", "max_temp_1", "temp_name2", "min_temp_2",
		"mean_temp_2", "max_temp_2", "temp_name3", "min_temp_3", "mean_temp_3", "max_temp_3", "temp_name4", "min_temp_4", "mean_temp_4",
		"max_temp_4", "spectral_type", "family", "magnitude", "abs_magnitude", "angular_size", "atmosphere_ref", "surface_pressure",
		"scale_height", "atmosphere_composition", "note", "tisserand", "label_width" }); // 109 non-deprecated params (excludes FrequentlyMalformedParamList)
	List<string> AllParamList = AlmostAllParamList.Concat(FrequentlyMalformedParamList).ToList(); // All 114 non-deprecated params (109 + 6 = 115)
	
	
	// auto-skip conditions /////////////////////////////////////////////////////
	
	// no {{Infobox planet}} or variants
	string InfoboxAliases_Pattern = @"Extrasolar Planet|Planet|Infobox (?:Moon|Nonstellarbody|Planet|asteroid|extrasolar planet|minor planet|small, medium[a-z, \(\)]+)";
	string InfoboxText_Pattern = @"\{\{\s*(" + InfoboxAliases_Pattern + @")\s*\|.+?[\r\n]+ *\|? *\}\}\s";
	Match mInfoboxExists = Regex.Match(ArticleText, @"\{\{\s*(" + InfoboxAliases_Pattern + @")\s*\|", RegexOptions.IgnoreCase);
	if (mInfoboxExists.Success)
	{
		// Attempt to isolate all {{Infobox}} text for faster processing, shorter regex, & fewer mismatches.
		// Infobox must end with "[\r\n]+ *\|? *}}\s".
		Match mInfoboxText1 = Regex.Match(ArticleText, InfoboxText_Pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline);
		if (mInfoboxText1.Success)
		{
			// make sure infobox isolation didn't grab too much
			string ArticleTitle_Pattern = @"([\r\n]+|\}\})[   ]*\'\'\'(" + ArticleTitle + @"|(\(\d+\) )?\{\{\s*mp\s*\|[^\}]+\}\})\'\'\'"; // typically designates the start of body-text
			Match mArticleTitle = Regex.Match(mInfoboxText1.Value, ArticleTitle_Pattern, RegexOptions.IgnoreCase);
			if (mArticleTitle.Success) Summary = @"{{Infobox}} doesn't end with ""}}"" on a separate line."; // skip
			
			// sterilize to "{{Infobox planet"
			NewInfobox = OldInfobox = mInfoboxText1.Value;
			NewInfobox = Regex.Replace(NewInfobox, @"\{\{\s*(" + InfoboxAliases_Pattern + ")", @"{{Infobox planet", RegexOptions.IgnoreCase);
		}
		else if (!mInfoboxText1.Success)
			Summary = @"{{Infobox}} doesn't end with ""}}"" on a separate line.";
	}
	else if (!mInfoboxExists.Success)
		Summary = @"No {{Infobox planet}} or alias.";
	
	if (Summary != OriginalSummary) // summary skip-condition
		Skip = true;
	
	
	// use ArticleTitle to determine Unique_ID for URL //////////////////////////
	
	// rep non-keyboard apostrophes/hyphens (even MPC's diacritized list only uses keyboard apostrophes for all but 1 MP)
	ArticleTitle_latin = Regex.Replace(ArticleTitle,       @"[‐–—-]", "-"); // i.e. WP's 6344 P–L == JPL's 6344 P-L
	ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"['‘’´`]", "'"); // EXCEPT 7613 `akikiki (WP == JPL == MPC)
	
	// ArticleTitle_latin = <prelim>?
	Match mIsPrelim_WP = Regex.Match(ArticleTitle_latin, @"^\d\d\d\d [A-Z][A-Z-][L\d-]{0,4}$");
	if ( mIsPrelim_WP.Success) Unique_ID = ArticleTitle_latin;
	if (!mIsPrelim_WP.Success)
	{
		// ArticleTitle_latin = "(#) <prelim>"?
		string NumPrelimPattern_WP = @"\((\d+)\) (\d\d\d\d [A-Z][A-Z-][L\d-]{0,4})$";
		Match mIsNumPrelim_WP = Regex.Match(ArticleTitle_latin, NumPrelimPattern_WP);
		if  (mIsNumPrelim_WP.Success) Unique_ID = mIsNumPrelim_WP.Groups[1].Value;
		if (!mIsNumPrelim_WP.Success)
		{
			// ArticleTitle_latin = "# <name>"?
			string NumNamePattern_WP = @"^(\d+) ([\w\s\.'-]+)";
			Match mIsNumName_WP = Regex.Match(ArticleTitle_latin, NumNamePattern_WP);
			if ( mIsNumName_WP.Success) Unique_ID = mIsNumName_WP.Groups[1].Value;
			if (!mIsNumName_WP.Success)
			{
				// if we get here, something's wrong
				Summary = @"Bad article name? Couldn't determine if ArticleTitle_latin = prelim, (#)+prelim, or #+name...";
				Skip = true;
			}
		}
	}
	
	
	// grab JPL HTML info ///////////////////////////////////////////////////////
	
	// get JPL page text
	string JPL_URL = @"http://ssd.jpl.nasa.gov/sbdb.cgi?sstr=" + Unique_ID.Replace(" ", "");
	string JPL_ExternalText = Tools.GetHTML(JPL_URL);
	
	string JPL_DiscoveryDatePattern = @"Discovered (\d\d\d\d)[\s‐–—-]*(\w+)\.?[\s‐–—-]*(\d\d?)";
	Match mJPL_DiscoveryDate = Regex.Match(JPL_ExternalText, JPL_DiscoveryDatePattern);
	
	string JPL_Designation_Pattern = @"1""\>\<b\>([^\<]+)\</b\>\</font\>\</td\>\</tr\>";
	string JPL_Designation = Regex.Match(JPL_ExternalText, JPL_Designation_Pattern).Groups[1].Value;
	
	
	// Skip if JPL != ArticleTitle //////////////////////////////////////////////
	
	// define 'regional' variables
	string MPprelim = "dummy MPprelim";
	string MPnumber = "dummy MPnumber";
	string MPname   = "dummy MPname";
	
	// JPL_Designation = ArticleTitle = "<prelim>"?
	Match mIsPrelim_JPL = Regex.Match(JPL_Designation, @"^\((\d\d\d\d [A-Z][A-Z‐–—-][L\d‐–—-]{0,4})\)$");
	if (mIsPrelim_JPL.Success && !Skip)
	{
		MPname = "";
		MPnumber = "";
		MPprelim = mIsPrelim_JPL.Groups[1].Value;
		
		// ArticleTitle_latin only has [‐–—-]['‘’´`] -> [-]['] at this point
		if (skipProvisionalJPLandWPMismatches && ArticleTitle_latin != MPprelim)
		{
			Summary = @"ArticleTitle_latin != JPL's prelim designation";
			Skip = true;
		}
	}
	else if (!mIsPrelim_JPL.Success && !Skip)
	{
		// JPL_Designation = "# (<prelim>)" = ArticleTitle = "(#) <prelim>"?
		string NumPrelimPattern_JPL = @"^(\d+) \((\d\d\d\d [A-Z][A-Z‐–—-][L\d‐–—-]{0,4})\)$";
		MPname = "";
		MPnumber = "";
		MPprelim = "";
		
		Match mIsNumPrelim_JPL = Regex.Match(JPL_Designation, NumPrelimPattern_JPL);
		if (mIsNumPrelim_JPL.Success)
		{
			MPname = "";
			MPnumber = mIsNumPrelim_JPL.Groups[1].Value;
			MPprelim = mIsNumPrelim_JPL.Groups[2].Value;
			
			if (ArticleTitle_latin != "(" + MPnumber + ") " + MPprelim)
			{
				Summary = @"ArticleTitle_latin != JPL's #+prelim";
				Skip = true;
			}
		}
		else if (!mIsNumPrelim_JPL.Success)
		{
			// JPL_Designation = "# <name> (<prelim>)"
			// JPL only starts including "(<prelim>)" AFTER ~332...It appears much less frequently <= 332.
			// Presumably, b/c the prelims for MP#s <= 332 weren't officially designated (b/c discovered before the 1890s).
			string NumNamePattern_JPL = @"^(\d+) ([\w\s\.'‘’´`‐–—-]+)(\s\()?";
			Match mIsNumName_JPL = Regex.Match(JPL_Designation, NumNamePattern_JPL);
			if (mIsNumName_JPL.Success)
			{
				MPname = mIsNumName_JPL.Groups[2].Value.Trim();
				MPnumber = mIsNumName_JPL.Groups[1].Value.Trim();
				MPprelim = "";
				
				// remove ArticleTitle diacritics to check JPL name, which doesn't use diacritics nor non-keyboard apostrophes (except 7613 `akikiki...)
				
				// remove lowercase diacritics from ArticleTitle (have to specially code for this since CharUnicodeInfo isn't available, it seems)
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[áàȧâäǎăāãåąⱥấầắằǡǻǟẫẵảȁȃẩẳạḁậặɑ̀āаⱥẚ]", "a");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ḃƀɓḅḇƃбᶀɓƀ]", "b");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ćċĉčçȼḉƈɔсȼƈȼƈ]", "c");
				
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ḋďḑđƌɗḍḓḏðɖɗɖᶁƌȡɗɖ]", "d");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[éèėêëěĕēẽęȩɇếềḗḕễḝẻȅȇểẹḙḛệɛəёеɇɇǝ]", "e");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ḟƒᶂ]", "f");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ǵġĝǧğḡģǥɠɣɠǥᶃ]", "g");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ḣĥḧȟḩħḥḫẖⱨħɦ]", "h");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ıíìîïǐĭīĩįɨḯỉȉȋịḭɩіɨ]", "i");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ĵǰɉ]", "j");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ḱǩķƙḳḵⱪĸкƙᶄⱪ]", "k");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ĺľɫⱡļƚłḷḽḻḹŀлłᶅƚȴⱡ]", "l");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ḿṁɱṃмᶆ]", "m");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ńǹṅňñņɲƞṇṋṉŋʼnƞȵᶇŋɲ]", "n");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[óòȯôöǒŏōõǫőốồɵøṓṑṍȫỗṏǿȭǭỏȍȏơổọớờỡộởợоøɵ]", "o");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ṕṗᵽƥᶈƥᵽ]", "p");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ɋʠ]", "q");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ŕṙřŗɍɽȑȓṛṟṝɍᶉ]", "r");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[śṡŝšṥṧṣșȿṩſᶊȿ]", "s");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ṫẗťţƭṭʈțṱṯⱦŧƭŧƫȶʈⱦ]", "t");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[úùûüǔŭūũůųűʉǘǜṹṻủȕȗưụṳứừṷṵữʊửựʉ]", "u");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ṽṿʋʋⱴ]", "v");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ẃẁẇŵẅẘẉⱳⱳ]", "w");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ẋẍхᶍ]", "x");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ýỳẏŷÿȳỹẙɏỷƴỵӳɏƴᶌ]", "y");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[źżẑžƶȥẓɀẕⱬƶᶎʐⱬȥɀ]", "z");
				
				// remove uppercase diacritics (like for 4901 Ó Briain)
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ÁÀȧÂÄǍĂĀÃÅĄⱥẤẦẮẰǠǺǞẪẴẢȀȂẨẲẠḀẬẶɑ̀ĀАȺ]", "A");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ḂƀƁḄḆƂɃƁ]", "B");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ĆĊĈČÇȼḈƇƆСȻƇ]", "C");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ḊĎḐĐƋƊḌḒḎÐƉƊƉƋ]", "D");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ÉÈĖÊËĚĔĒẼĘȩɇẾỀḖḔỄḜẺȄȆỂẸḘḚỆƐƏЁЕƎƐɆ]", "E");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ḞƑƑ]", "F");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ǴĠĜǦĞḠĢǤƓƔƓǤ]", "G");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ḢĤḦȟḨĦḤḪẖĦⱧ]", "H");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[IÍÌÎÏǏĬĪĨĮƗḮỈȈȊỊḬƖІƗ]", "I");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ĴǰɉɈ]", "J");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ḰǨĶƘḲḴКƘⱩ]", "K");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ĹĽɫⱡĻƚŁḶḼḺḸĿŁȽⱠⱢ]", "L");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ḾṀɱṂМ]", "M");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ŃǹṄŇÑŅƝƞṆṊṈŊƝȠŊ]", "N");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ÓÒȯÔÖǑŎŌÕǪŐỐỒƟØṒṐṌȫỖṎǾȭǬỎȌȎƠỔỌỚỜỠỘỞỢОƟØ]", "O");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ṔṖᵽƤⱣƤ]", "P");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ɋ]", "Q");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ŔṘŘŖɍɽȐȒṚṞṜɌⱤ]", "R");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ŚṠŜŠṤṦṢșȿṨ]", "S");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ṪẗŤŢƬṬƮțṰṮⱦŦŦƬƮȾ]", "T");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ÚÙÛÜǓŬŪŨŮŲŰʉǗǛṸṺỦȔȖƯỤṲỨỪṶṴỮƱỬỰɄ]", "U");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ṼṾƲ]", "V");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ẂẀẆŴẄẘẈⱳƜⱲ]", "W");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ẊẌХ]", "X");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ÝỲẎŶŸȳỸẙɏỶƳỴӲƳɎ]", "Y");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ŹŻẐŽƵȥẒɀẔⱬƵⱫȤ]", "Z");
				
				// other, from https://sourceforge.net/p/autowikibrowser/code/HEAD/tree/AWB/WikiFunctions/Tools.cs#l1181
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ÆǢǼ]", "Ae");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[æǣǽ]", "ae");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[DžDz]", "Dz");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[fl]", "fl");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[Lj]", "Lj");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[lj]", "lg");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[Nj]", "Nj");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[№]", "No");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[nj]", "ng");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[Œ]", "Oe");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[œ]", "oe");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[ß]", "ss");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[Þ]", "Th");
				ArticleTitle_latin = Regex.Replace(ArticleTitle_latin, @"[þ]", "th");
				
				string JPL_MPnumname = MPnumber + " " + MPname;
				if (ArticleTitle_latin != JPL_MPnumname)
				{
					if (JPL_Designation != @"7613 `akikiki (1996 DK)" && skipMisspelledArticleTitles)
					{
						Summary = @"ArticleTitle_latin != JPL's #+name designation.";
						Skip = true;
					}
				}
			}
			
			// if we get here, something's wrong
			// unless it's 7613 `akikiki (1996 DK), where JPL decides NOT to use a keyboard single quote
			if (skipProvisionalJPLandWPMismatches && Unique_ID == ArticleTitle && !mIsNumName_JPL.Success)
			{
			   if (Regex.Match(ArticleText, @"\[\[Category:Lost minor planets").Success)
					Summary = @"Lost minor planet, and mismatch b/w JPL & WP";
			   else
					Summary = @"Bad article name? Provisional name mismatch b/w JPL & WP.";
				Skip = true;
			}
			else if (skipAlmostAllJPLandWPMismatches && !mIsNumName_JPL.Success)
			{
				if (JPL_Designation != "7613 `akikiki (1996 DK)")
				{
					Summary = @"Bad article name? Couldn't determine if JPL_Designation = prelim, (#)+prelim, or #+name...";
					Skip = true;
				}
			}
		} // end else if(!mIsNumPrelim_JPL.Success)
	} // end else if(!mIsPrelim_JPL.Success)
	
	
	// clean/combine inputs /////////////////////////////////////////////////////
	
	// define 'regional' variables
	string JPL_DDay   = "dummy JPL_DDay";
	string JPL_DMonth = "dummy JPL_DMonth";
	string JPL_DYear  = "dummy JPL_DYear";
	
	if (mJPL_DiscoveryDate.Success && !Skip)
	{
		// leave days without 0 padding
		JPL_DDay   = mJPL_DiscoveryDate.Groups[3].Value.TrimStart('0');
		
		// convert month to full name
		JPL_DMonth = mJPL_DiscoveryDate.Groups[2].Value;
		
		switch (JPL_DMonth)
		{
			case "Jan": JPL_DMonth="January";  break;
			case "Feb": JPL_DMonth="February"; break;
			case "Mar": JPL_DMonth="March"; break;
			case "Apr": JPL_DMonth="April"; break;
			case "May": JPL_DMonth="May";   break;
			case "June": // exists
			case "Jun": JPL_DMonth="June";  break;
			case "July": // exists
			case "Jul": JPL_DMonth="July";  break;
			case "Aug": JPL_DMonth="August"; break;
			case "Sept": // exists?
			case "Sep": JPL_DMonth="September"; break;
			case "Oct": JPL_DMonth="October";  break;
			case "Nov": JPL_DMonth="November"; break;
			case "Dec": JPL_DMonth="December"; break;
			default:
				Summary = @"Month: '" + JPL_DMonth + "' not found!";
				Skip = true;
				break;
		}
		
		JPL_DYear = mJPL_DiscoveryDate.Groups[1].Value;
		
		// combine as DMY
		JPL_DDate = JPL_DDay + " " + JPL_DMonth + " " + JPL_DYear;
	}
	else JPL_DDate = "";
	
	
	// Preparatory infobox-only searches & changes //////////////////////////////
	
	// replace whitespace-b/w-values-&-refs with &thinsp;
	if (!Skip)
	{
		// \b[a-z]{1,5} to cover most units & ignore longer words
		string ValRef_Pattern = @"(\{\{(?:Convert|Val|Small|Deg2DMS|Deg2HMS|e\|)[^\}]+\}\}|\]\]|\d+|\b[a-z]{1,5}|met[er][re]s?)(\s+)(\<ref|\{\{efn|\{\{cite sbdb)";
		Match mValRef = Regex.Match(NewInfobox, ValRef_Pattern, RegexOptions.IgnoreCase);
		if (mValRef.Success) NewInfobox = Regex.Replace(NewInfobox, ValRef_Pattern, @"$1&thinsp;$3", RegexOptions.IgnoreCase);
	}
	
	// move lines starting w "<ref" or "</ref" up 1 line
	string RefLine_Pattern = "[\r\n]+" + @"(\s*\</?ref)";
	Match mRefLine = Regex.Match(NewInfobox, RefLine_Pattern, RegexOptions.IgnoreCase);
	if (mRefLine.Success) NewInfobox = Regex.Replace(NewInfobox, RefLine_Pattern, @"$1", RegexOptions.IgnoreCase);
	
	// unicodify "&thinsp;"s to " " in infobox ONLY
	NewInfobox = NewInfobox.Replace(@"&thinsp;", " "); // unicodify during processing; DEunicodify back to html at the end
	
	// determine the &thinsp; usage fraction and enforce &thinsp; usage later if > threshold %
	string ThinspCount_Pattern = @"(\{\{(?:Convert|Val|Small|Deg2DMS|Deg2HMS|e\|)[^\}]+\}\}|\]\]|\)|\d+|['""a-z]|)(&thinsp;| )(\<ref|\{\{efn)"; // thinsp required; [a-z] to cover all possible units
	double ThinspCount = Regex.Matches(NewInfobox, ThinspCount_Pattern, RegexOptions.IgnoreCase).Count;
	
	string MaxPotentialThinsps_Pattern = @"(\{\{(?:Convert|Val|Small|Deg2DMS|Deg2HMS|e\|)[^\}]+\}\}|\]\]|\)|\d+|['""a-z])(&thinsp;| )?(\<ref|\{\{efn)"; // thinsp optional
	double MaxPotentialThinsps = Regex.Matches(NewInfobox, MaxPotentialThinsps_Pattern, RegexOptions.IgnoreCase).Count;
	
	double ThinspUsageFraction = ThinspCount / MaxPotentialThinsps;
	if (ThinspUsageFraction > 0.4) // if > 40%, make it a thing (100% usage ratio)
	{
		ThinspRefs = " ";
		ThinspRefs_HTML = "&thinsp;";
	}
	
	// determine &thinsp; usage in headings (different from usage between values & refs)
	string ThinspHeadings_Pattern = @"\|\s*[\w_]+_ref\s*= *(&thinsp;| )([^\r\n]{5,})"; // orbit_ref, etc.; ">= 5" since "<ref>" = 5 characters long
	int ThinspHeadingsCount = Regex.Matches(NewInfobox, ThinspHeadings_Pattern, RegexOptions.IgnoreCase).Count;
	if (ThinspHeadingsCount > 0 | !string.IsNullOrEmpty(ThinspRefs)) ThinspHeadings = " ";
	
	// rem text selectively after last <br>
	foreach (string param in UpdatableParamList)
	{
		// remove "<br>([[Uncertainty Parameter U|Uncertainty]]=8)<ref name=jpldata/>" and the like
		string BR_Pattern = @"(\|\s*" + param + @"\s*=[^\r\n\<]*?)\<br */?\>[^\r\n]*?Uncertainty Parameter[^\r\n]*";
		Match mBR = Regex.Match(NewInfobox, BR_Pattern, RegexOptions.IgnoreCase);
		if (mBR.Success) NewInfobox = Regex.Replace(NewInfobox, BR_Pattern, @"$1", RegexOptions.IgnoreCase);
		
		// remove last "<br>" & subsequent in-line IB text IF a ref/efn/cite sbdb doesn't exist after on that line AND one does exist before the last <br>
		BR_Pattern = @"(\|\s*" + param + @"\s*=[^\r\n]*)\<br */?\>(?![^\r\n]*(?:\<ref|\{\{efn|\{\{cite sbdb))";
		mBR = Regex.Match(NewInfobox, BR_Pattern, RegexOptions.IgnoreCase);
		if (mBR.Success)
		{
			Match mRef = Regex.Match(mBR.Groups[1].Value, @"(\<ref|\{\{efn|\{\{cite sbdb)", RegexOptions.IgnoreCase); // i.e. to exclude 705 Erminia's dimensions param
			if (mRef.Success) NewInfobox = Regex.Replace(NewInfobox, BR_Pattern, @"$1", RegexOptions.IgnoreCase);
		}
		
		// remove last "<br>" & subsequent in-line IB text, no matter what, for specific params
		if (param == "period")
		{
			BR_Pattern = @"(\|\s*" + param + @"\s*=[^\r\n]*)\<br */?\>[^\r\n]*";
			mBR = Regex.Match(NewInfobox, BR_Pattern, RegexOptions.IgnoreCase);
			if (mBR.Success) NewInfobox = Regex.Replace(NewInfobox, BR_Pattern, @"$1", RegexOptions.IgnoreCase);
		}
	}
	
	// remove "<ref>Osculating Orbital Elements</ref>" and the like from infobox
	string LatinOnlyRef_Pattern = @"\<ref\>[\sa-z]+\</ref\>";
	Match mLatinOnlyRef = Regex.Match(NewInfobox, LatinOnlyRef_Pattern, RegexOptions.IgnoreCase);
	if (mLatinOnlyRef.Success) NewInfobox = Regex.Replace(NewInfobox, LatinOnlyRef_Pattern, "", RegexOptions.IgnoreCase);
	
	// remove "<sup>o</sup>" and the like from infobox
	string UnnecessarySups_Pattern = @"\<sup\>[Oo°]\</sup\>[\)\]]?";
	Match mUnnecessarySups = Regex.Match(NewInfobox, UnnecessarySups_Pattern, RegexOptions.IgnoreCase);
	if (mUnnecessarySups.Success) NewInfobox = Regex.Replace(NewInfobox, UnnecessarySups_Pattern, "", RegexOptions.IgnoreCase);
	
	// replace "([[IRAS]])" -> {{small|([[IRAS]])}}
	string BareIRAS_Pattern = @"(?<!small\s*\|\s*)(\(\s*)?\[\[\s*IRAS\s*\]\]\s*(\:?\d?\)?)";
	Match mBareIRAS = Regex.Match(NewInfobox, BareIRAS_Pattern, RegexOptions.IgnoreCase);
	if (mBareIRAS.Success) NewInfobox = Regex.Replace(NewInfobox, BareIRAS_Pattern, @"{{small|$1[[IRAS]]$2}}", RegexOptions.IgnoreCase);
	
	// Preparatory ArticleText-only searches & changes //////////////////////////
	
	// don't isolate Infobox text until the next section
	ArticleText = ArticleText.Replace(OldInfobox, NewInfobox); // save infobox changes
	OldInfobox = NewInfobox;
	
	// fix typo "JP: Small-body" -> "JPL Small-body" and the like in ArticleText
	string Typo_Pattern = @"JP[^L][ ]+(Small)[ ‐–—-]*(body)";
	Match mTypo = Regex.Match(ArticleText, Typo_Pattern, RegexOptions.IgnoreCase);
	if (mTypo.Success) ArticleText = Regex.Replace(ArticleText, Typo_Pattern, @"JPL $1-$2", RegexOptions.IgnoreCase);
	
	// Search ArticleText for 1) ref name="jpldata", 2) "jpl", 3) "*jpl|sbdb|orbit*", then 4) ANY named ref with ssd.jpl.nasa.gov/sbdb.cgi.
	// Put whichever wins first into "RefName_jpl".
	string RefName_jpl_Pattern = @"\<ref name\s*=\s*(""?jpldata""?)\s*\>\s*(\{\{)?"; // #1
	Match mRefName_jpl = Regex.Match(ArticleText, RefName_jpl_Pattern, RegexOptions.IgnoreCase);
	if (!mRefName_jpl.Success)
	{
		RefName_jpl_Pattern = @"\<ref name\s*=\s*(""?jpl""?)\s*\>\s*(\{\{)?"; // #2
		mRefName_jpl = Regex.Match(ArticleText, RefName_jpl_Pattern, RegexOptions.IgnoreCase);
		if (!mRefName_jpl.Success)
		{
			RefName_jpl_Pattern = @"\<ref name\s*=\s*([^\>]*(?:" + JPLRefNameVariants + @")[^/\>]*?)\s*\>\s*(\{\{)?"; // #3
			mRefName_jpl = Regex.Match(ArticleText, RefName_jpl_Pattern, RegexOptions.IgnoreCase);
			if (!mRefName_jpl.Success)
			{
				RefName_jpl_Pattern = @"\<ref name\s*=\s*([^\>]*?)\s*(?<!/)\>(\s*\{\{)?[^\<]*ssd\.jpl\.nasa\.gov/sbdb\.cgi[^\<]+?\</ref\>"; // #4
				mRefName_jpl = Regex.Match(ArticleText, RefName_jpl_Pattern, RegexOptions.IgnoreCase);
				if (mRefName_jpl.Success) JPLRefNameVariants += @"|" + mRefName_jpl.Groups[1].Value.Trim(); // add new found name to JPLRefNameVariants
			}
		}
	}
	if ( mRefName_jpl.Success) RefName_jpl = mRefName_jpl.Groups[1].Value.Trim(); // one of them exists; assume it's good
	if (!mRefName_jpl.Success) RefName_jpl = @"""jpldata"""; // none exist; build master named "jpldata"
	
	JPLDataRef_Master = @"<ref name=" + RefName_jpl + @">{{Cite web" + // modeled after {{Cite SBDB}}
							  @" |url=" + JPL_URL + @";cad=1" + // cad=1 to show Close Approach Data, if available
							  @" |title=" + JPL_Designation +
							  @" |work=[[JPL Small-Body Database]]" +
							  @" |publisher=[[NASA]]/[[Jet Propulsion Laboratory]]" +
							  @" |access-date=" + DateTime.Today.ToString("d MMMM yyyy") +
							  @"}}</ref>"; // entire master ref is rendered on 1 line
	string JPLDataRef_Slave = @"<ref name=" + RefName_jpl + @" />";
	
	// Search ArticleText for ref name="*lowell*", "*astorb*", then "*AOED*". Put whichever wins first into "RefName_lowell".
	string RefName_lowell_Pattern = @"\<ref name\s*=\s*([^\>]*lowell[^/\>]*?)\s*\>\s*(\{\{)?";
	Match mRefName_lowell = Regex.Match(ArticleText, RefName_lowell_Pattern, RegexOptions.IgnoreCase);
	if (!mRefName_lowell.Success)
	{
		RefName_lowell_Pattern = @"\<ref name\s*=\s*([^\>]*astorb[^/\>]*?)\s*\>\s*(\{\{)?";
		mRefName_lowell = Regex.Match(ArticleText, RefName_lowell_Pattern, RegexOptions.IgnoreCase);
		if (!mRefName_lowell.Success)
		{
			RefName_lowell_Pattern = @"\<ref name\s*=\s*([^\>]*AOED[^/\>]*?)\s*\>\s*(\{\{)?";
			mRefName_lowell = Regex.Match(ArticleText, RefName_lowell_Pattern, RegexOptions.IgnoreCase);
		}
	}
	if ( mRefName_lowell.Success) RefName_lowell = mRefName_lowell.Groups[1].Value; // one of them exists; assume it's good
	if (!mRefName_lowell.Success) RefName_lowell = @"""lowell"""; // none exist; build master named "lowell"
	
	string Lowell_URL = @"ftp://ftp.lowell.edu/pub/elgb/astorb.html";
	LowellRef_Master = @"<ref name=" + RefName_lowell + @">{{Cite web" +
							  @" |url=" + Lowell_URL +
							  @" |website=astorb" +
							  @" |title=The Asteroid Orbital Elements Database" +
							  @" |publisher=[[Lowell Observatory]]" +
							  @"}}</ref>"; // entire master ref is rendered on 1 line
	string LowellRef_Slave = @"<ref name=" + RefName_lowell + @" />";
	
	// determine if JPL & Lowell master refs probably exist (ref name + "{{" are a good first sign)
	if (!string.IsNullOrEmpty(mRefName_jpl.Groups[2].Value))    jplDataMasterExists = true;
	if (!string.IsNullOrEmpty(mRefName_lowell.Groups[2].Value)) lowellMasterExists  = true;
	
	// check original JPL ref's access-date and skip if updated too recently (user-defined)
	string JPLRef_Pattern = @"\<ref(?: name\s*=\s*" + RefName_jpl + @"\s*|[^\>]*)?\>" +
		@"[^\<]*(Cite SBDB[^\<]*access\-?date\s*=|" +
		@"access\-?date\s*=[^\<]*ssd\.jpl\.nasa\.gov/sbdb\.cgi|" +
		@"ssd\.jpl\.nasa\.gov/sbdb\.cgi[^\<]*access\-?date\s*=)[^\<]*\</ref\>";
	Match mJPLRef = Regex.Match(ArticleText, JPLRef_Pattern, RegexOptions.IgnoreCase);
	if (mJPLRef.Success && skipIfRecentlyUpdated && !Skip)
	{
		string JPLRef = mJPLRef.Value;
		SkipIfRecentlyUpdated_InMonth = SkipIfRecentlyUpdated_InMonth.ToUpper();
		
		string AccessDate_Pattern = @"\|\s*access-?date\s*=\s*([^\|\}\<]*)";
		Match mAccessDate = Regex.Match(JPLRef, AccessDate_Pattern, RegexOptions.IgnoreCase);
		string AccessDate = mAccessDate.Groups[1].Value.Trim(); // don't ToUpper() so it displays as-written in edit summary
		if (!string.IsNullOrEmpty(AccessDate))
		{
			int UpdatedRecently = -1;
			string AccessDate_Month = "";
			string AccessDate_Year  = "";
			Match mAccessDate_Year = Regex.Match(AccessDate, @"\d\d\d\d");
			Match mAccessDate_MMM = Regex.Match(AccessDate, @"[a-z]{3,}", RegexOptions.IgnoreCase);
			if (mAccessDate_MMM.Success && mAccessDate_Year.Success) // MMM or MMMM
			{
				AccessDate_Month = mAccessDate_MMM.Value.ToUpper();
				AccessDate_Year  = mAccessDate_Year.Value;
			}
			else if (!mAccessDate_MMM.Success && mAccessDate_Year.Success) // YMD, DMY, MDY
			{
				Match mYMD = Regex.Match(AccessDate, @"(\d\d\d\d)[ -]+(\d\d)[ -]+(\d\d)");
				if (mYMD.Success) // if ####-##-##, assume yyyy-mm-dd
				{
					AccessDate_Year  = mYMD.Groups[1].Value;
					AccessDate_Month = mYMD.Groups[2].Value;
					switch (AccessDate_Month)
					{
						case "1": case "01": AccessDate_Month="JANUARY";  break;
						case "2": case "02": AccessDate_Month="FEBRUARY"; break;
						case "3": case "03": AccessDate_Month="MARCH"; break;
						case "4": case "04": AccessDate_Month="APRIL"; break;
						case "5": case "05": AccessDate_Month="MAY";   break;
						case "6": case "06": AccessDate_Month="JUNE";  break;
						case "7": case "07": AccessDate_Month="JULY";  break;
						case "8": case "08": AccessDate_Month="AUGUST"; break;
						case "9": case "09": AccessDate_Month="SEPTEMBER"; break;
						case "10": AccessDate_Month="OCTOBER";  break;
						case "11": AccessDate_Month="NOVEMBER"; break;
						case "12": AccessDate_Month="DECEMBER"; break;
						default:
							Summary += @"; JPL's accessdate (" + mYMD.Value + @") month not found (" + AccessDate_Month + @")";
							Skip = true;
							break;
					}
				}
				else if (!mYMD.Success) ; // don't feel like checking for DMY/MDY access-dates
			}
			
			if (SkipIfRecentlyUpdated_InMonth.Length >= 3)
			{
				if (SkipIfRecentlyUpdated_InMonth.IndexOf(AccessDate_Month) > -1 &&
					 SkipIfRecentlyUpdated_InYear.IndexOf( AccessDate_Year)  > -1)
					UpdatedRecently = 1;
			}
			else if (string.IsNullOrEmpty(SkipIfRecentlyUpdated_InMonth))
				UpdatedRecently = SkipIfRecentlyUpdated_InYear.IndexOf(AccessDate_Year);
			
			if (UpdatedRecently >= 0)
			{
				Summary = @"MP info updated recently (" + AccessDate + @")";
				Skip = true;
			}
		}
	}
	
	// replace existing, bare-link, lowell-refs with lowell master and/or slaves
	int FilledIn = 0;
	bool loop = true;
	while (loop && !Skip)
	{
		// determine which to place
		LowellRef_MasterOrSlave = (lowellMasterExists) ? LowellRef_Slave : LowellRef_Master;
		
		string BareRef_Pattern = @"\<ref\s*(name\s*=\s*" + RefName_lowell + @"\s*)?\>\s*\[.+?ftp\.lowell\.edu.+?astorb.+?\]\</ref\>";
		Match mBareRef = Regex.Match(ArticleText, BareRef_Pattern, RegexOptions.Singleline);
		
		// You can't overload a 1-line "Regex.Replace" to only replace the 1st match, but you CAN overload a "new Regex". Thanks, C#.
		Regex rBareRef = new Regex(BareRef_Pattern);
		if (mBareRef.Success)
		{
			ArticleText = rBareRef.Replace(ArticleText, LowellRef_MasterOrSlave, 1);
			FilledIn++;
			lowellMasterExists = true; // if not true before, it's definitely true now
			LowellRef_MasterOrSlave = LowellRef_Slave; // force slave after first placement, in case master was placed
		}
		else loop = false;
		
		if (FilledIn > 50) loop = false; // to prevent an infinite loop
		if (!loop && FilledIn > 0)
		{
			string Suffix = (FilledIn > 1) ? "s" : "";
			if (!string.IsNullOrEmpty(mBareRef.Groups[1].Value)) Summary += @"; filled in " + FilledIn + @" bare <ref name=" + RefName_lowell + @">";
			else Summary += @"; filled in " + FilledIn + @" bare [ftp.lowell.edu] ref" + Suffix;
		}
	}
	
	// replace existing, bare-link, jpl-refs with jpl master and/or slaves
	FilledIn = 0;
	loop = true;
	while (loop && !Skip)
	{
		// determine which to place
		JPLDataRef_MasterOrSlave = (jplDataMasterExists) ? JPLDataRef_Slave : JPLDataRef_Master;
		
		string BareRef_Pattern = @"\<ref\s*(name\s*=\s*" + RefName_jpl + @"\s*)?\>\s*\[[^\<]+?ssd\.jpl\.nasa\.gov/sbdb\.cgi[^\<]+?\</ref\>";
		Match mBareRef = Regex.Match(ArticleText, BareRef_Pattern, RegexOptions.Singleline);
		Regex rBareRef = new Regex(BareRef_Pattern); // req'd for replacing 1 match at a time, otherwise end up with multiple masters
		if (mBareRef.Success)
		{
			ArticleText = rBareRef.Replace(ArticleText, JPLDataRef_MasterOrSlave, 1);
			FilledIn++;
			jplDataMasterExists = true; // if not true before, it's definitely true now
			JPLDataRef_MasterOrSlave = JPLDataRef_Slave; // force slave after first placement, in case master was placed
		}
		else loop = false;
		
		if (FilledIn > 50) loop = false; // to prevent an infinite loop
		if (!loop && FilledIn > 0)
		{
			string Suffix = (FilledIn > 1) ? "s" : "";
			if (!string.IsNullOrEmpty(mBareRef.Groups[1].Value)) Summary += @"; filled in " + FilledIn + @" bare <ref name=" + RefName_jpl + @">";
			else Summary += @"; filled in " + FilledIn + @" bare [ssd.jpl.nasa.gov] ref" + Suffix;
		}
	}
	
	// ref-wrap any remaining bare links in |orbit_ref= (to do: expand this to all ArticleText?)
	string OrbitRefBareLink_Pattern = @"(\|\s*orbit_ref\s*=\s*)(\[+ *(?:ftp|http|www)[^\]]+\]+)"; // "\s*" since malformed params not fixed yet
	Match mOrbitRefBareLink = Regex.Match(ArticleText, OrbitRefBareLink_Pattern);
	if (mOrbitRefBareLink.Success)
	{
		string RefWrapped = mOrbitRefBareLink.Groups[1].Value + @"<ref>" + mOrbitRefBareLink.Groups[2].Value + @"</ref>";
		ArticleText = ArticleText.Replace(mOrbitRefBareLink.Value, RefWrapped);
	}
	
	// replace any unnamed refs with "ssd.jpl.nasa.gov/sbdb.cgi?sstr=" or "{{Cite SBDB" with JPL master or slave
	int Named = 0;
	string UnnamedJPLRef_Pattern = @"\<ref\>(\s*\{\{\s*Cite SBDB|[^\<]+?ssd\.jpl\.nasa\.gov/sbdb\.cgi\?sstr\=)[^\<]+?\</\s*ref\>";
	foreach (Match m in Regex.Matches(ArticleText, UnnamedJPLRef_Pattern, RegexOptions.IgnoreCase))
	{
		Named++;
		JPLDataRef_MasterOrSlave = (jplDataMasterExists) ? JPLDataRef_Slave : JPLDataRef_Master;
		ArticleText = ArticleText.Replace(m.Value, JPLDataRef_MasterOrSlave);
		jplDataMasterExists = true;
	}
	if (Named > 0)
	{
		string Plural = (Named > 1) ? "s" : "";
		Summary += @"; master/slave'd " + Named + " [ssd.jpl.nasa.gov/sbdb] ref" + Plural;
	}
	
	// replace any unnamed refs with "ftp.lowell.edu...astorb" with Lowell master or slave
	Named = 0;
	string UnnamedLowellRef_Pattern = @"\<ref\>[^\<]+?ftp\.lowell\.edu[^\<]+?astorb[^\<]+?\</\s*ref\>";
	foreach (Match m in Regex.Matches(ArticleText, UnnamedLowellRef_Pattern))
	{
		Named++;
		LowellRef_MasterOrSlave = (lowellMasterExists) ? LowellRef_Slave : LowellRef_Master;
		ArticleText = ArticleText.Replace(m.Value, LowellRef_MasterOrSlave);
		lowellMasterExists = true;
	}
	if (Named > 0)
	{
		string Plural = (Named > 1) ? "s" : "";
		Summary += @"; master/slave'd " + Named + " [ftp.lowell.edu] ref" + Plural;
	}
	
	
	// Preparatory infoboxes formatting fixes ///////////////////////////////////
	
	// now we're ready to re-isolate {{Infobox planet}} for making many, many changes exclusive to Infobox text
	Match mInfoboxText2 = Regex.Match(ArticleText, InfoboxText_Pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline);
	if (mInfoboxText2.Success && !Skip)
	{
		// make sure infobox isolation didn't grab too much
		string ArticleTitle_Pattern = @"[\r\n]+\'\'\'(" + ArticleTitle + @"|(\(\d+\) )?\{\{\s*mp\s*\|[^\}]+\}\})\'\'\'"; // typically designates the start of body-text
		Match mArticleTitle = Regex.Match(mInfoboxText2.Value, ArticleTitle_Pattern, RegexOptions.IgnoreCase);
		if (mArticleTitle.Success) Summary = @"{{Infobox}} doesn't end with ""}}"" on a separate line."; // skip
		
		NewInfobox = OldInfobox = mInfoboxText2.Value;
	}
	else if (!mInfoboxText2.Success && !Skip)
	{
		Summary = @"{{Infobox}} doesn't end with ""}}"" on a separate line (2nd try).";
		Skip = true;
	}
	
	// move end-of-line-pipes "|" down to the next line while removing extra "\r\n"s b/w "|" & param names
	string EoLPipe_Pattern = @"( *\|) *" + "[\r\n]+" + @"( *[a-z_]{4,})";
	Match mEoLPipe = Regex.Match(NewInfobox, EoLPipe_Pattern);
	if (mEoLPipe.Success && !Skip)
		NewInfobox = Regex.Replace(NewInfobox, EoLPipe_Pattern, "\n" + mEoLPipe.Groups[1].Value + mEoLPipe.Groups[2].Value);
	
	// move any parameters on the "{{Infobox planet" line to the next line
	string InlineParams_Pattern = @"(\{\{Infobox planet)( *\| *[^\r\n]+)";
	Match mInlineParams = Regex.Match(NewInfobox, InlineParams_Pattern);
	if (mInlineParams.Success && !Skip)
		NewInfobox = Regex.Replace(NewInfobox, InlineParams_Pattern, @"$1" + "\n" + @"$2");
	
	// split multiple in-line parameters from 1 line to multiple lines
	string MultipleILPs_Pattern = @"((?<=[\r\n]) *\| *[a-z_]{4,} *= *[^\|\r\n\{]*?)(\[\[[^\]]+\]\])?(\{\{[^\{\}]+\}\})?([^\[\|\r\n\{]*?)(\[\[[^\]]+\]\])?( +\||\| +)(?![^\r\n]*\}\})"; // 6 grps
	loop = true;
	while (loop)
	{
		// Using "foreach (Match m in Regex.Matches(NewInfobox, MultipleILPs_Pattern))"
		// with "(?<!\{\{[A-Za-z ]*?)" in the pattern will return only 1 match, even if there are more...
		// Looping over matches in TempNewInfobox while operating exclusively on NewInfobox doesn't work either.
		// Therefore, have to use a while-loop instead of a foreach. Anyone know why?!
		// Makes me question the integrity of all my other foreach Regex.Matches......
		Match mMultipleILPs = Regex.Match(NewInfobox, MultipleILPs_Pattern);
		if (mMultipleILPs.Success) NewInfobox = Regex.Replace(NewInfobox, MultipleILPs_Pattern, @"$1$2$3$4$5" + "\n" + @"$6");
		else loop = false;
	}
	
	// move text (usually trailing units) from between final <ref>/{{template}} and endofline to before final <ref>/{{templ}} (can't look past multiline {{cite}}s) (5 groups)
	string TrailingText_Pattern = @"( *\| *(?!discovery|alt_names)[a-z_]+ *= *[^\r\n]*)( ?\<| ?\{\{(?!(?:e|·|Gr)[\|\}]))([^\r\n]+)(\}\}\</ref\>|(?<!br */?|sup)\>|\}\})([^\{\}\r\n]+?)" + "[\r\n]+";
	Match mTrailingText = Regex.Match(NewInfobox, TrailingText_Pattern, RegexOptions.IgnoreCase);
	if (mTrailingText.Success)
	{
		string TrailingText = mTrailingText.Groups[5].Value;
		if (TrailingText.Length > 0)
		{
			// instead of incorporating this into the initital pattern, separating it here for clarity, anticipating add'l exceptions
			int Exception_Count = Regex.Matches(TrailingText, @"\</?ref", RegexOptions.IgnoreCase).Count;
			if (Exception_Count == 0) NewInfobox = Regex.Replace(NewInfobox, TrailingText_Pattern, @"$1$5$2$3$4" + "\n", RegexOptions.IgnoreCase);
			else // try again, slightly stricter regex this time
			{
				TrailingText_Pattern = @"( *\| *(?!discovery|alt_names)[a-z_]+ *= *[^\r\n]*)( ?\<| ?\{\{(?!(?:e|·|Gr)[\|\}]))([^\r\n]+)(\}\}\</ref\>|(?<!br */?|sup)\>|\}\})([^\<\>\{\}\r\n]+?)" + "[\r\n]+";
				mTrailingText = Regex.Match(NewInfobox, TrailingText_Pattern, RegexOptions.IgnoreCase);
				if (mTrailingText.Success)
					if (mTrailingText.Groups[5].Value.Length > 0)
						NewInfobox = Regex.Replace(NewInfobox, TrailingText_Pattern, @"$1$5$2$3$4" + "\n", RegexOptions.IgnoreCase);
			}
		}
	}
	
	
	// Orbital Elements Table -> Infobox ////////////////////////////////////////
	
	// declare Orbital Elements regionals
	Dictionary<string, int>     OEWPSigFigs   = new Dictionary<string, int>();
	Dictionary<string, int>     OEJPLSigFigs  = new Dictionary<string, int>();
	Dictionary<string, decimal> OEValues      = new Dictionary<string, decimal>();
	Dictionary<string, string>  OEValStr      = new Dictionary<string, string>();
	Dictionary<string, string>  OEErrors      = new Dictionary<string, string>();
	Dictionary<string, string>  OEPatterns    = new Dictionary<string, string>();
	Dictionary<string, string>  OEUnits       = new Dictionary<string, string>();
	Dictionary<string, string>  OEUnitsExpected = new Dictionary<string, string>();
	Dictionary<string, string>  OESymbols     = new Dictionary<string, string>();
	
	// isolate the "Orbital Elements" table & save components
	string OrbitalElements_Pattern = @"Orbital\s+Elements\s+at\s+Epoch.+Orbit\s+Determination\s+Parameters";
	Match mOrbitalElements = Regex.Match(JPL_ExternalText, OrbitalElements_Pattern, RegexOptions.Singleline);
	if (mOrbitalElements.Success && !Skip)
	{
		string OrbitalElements = mOrbitalElements.Value;
		
		bool isJ2000 = Regex.Match(OrbitalElements, "J2000").Success;
		if (isJ2000)
		{
			OriginalSummary = Summary; // use summary to catch exceptions and trigger a skip condition for OE units only
			
			// find & store Epoch & JD
			string EpochJD, JD;
			EpochJD = JD = "";
			Match mJD = Regex.Match(OrbitalElements, @"Epoch ([\d\.]+)"); // JPL mixes up JD & Epoch
			if (mJD.Success)
			{
				JD = mJD.Groups[1].Value;
				Match mEpoch = Regex.Match(OrbitalElements, @"Epoch [\d\.]+ \(([^\)]+)\)");
				if (mEpoch.Success)
				{
					// format Epoch from YMD to DMY
					string EpochRaw = mEpoch.Groups[1].Value;
					string EpochYear, EpochMonth, EpochDay;
					EpochYear = EpochMonth = EpochDay = "";
					string[] EpochRawSplit = Regex.Split(EpochRaw, "-");
					foreach (string val in EpochRawSplit)
					{
						if      (Regex.Match(val, @"\d\d\d\d").Success)  EpochYear  = val;
						else if (Regex.Match(val, @"[A-Za-z]+").Success) EpochMonth = val;
						else if (Regex.Match(val, @"[\d\.]+").Success)   EpochDay   = val;
					}
					
					// 01.0 -> 1 (I have yet to see any non-integer values used for EpochDay)
					EpochDay = EpochDay.Trim('0').Trim('.'); // will ammend if/as necessary
					
					switch (EpochMonth)
					{
						case "Jan": EpochMonth="January";  break;
						case "Feb": EpochMonth="February"; break;
						case "Mar": EpochMonth="March"; break;
						case "Apr": EpochMonth="April"; break;
						case "May": EpochMonth="May";   break;
						case "June": // exists
						case "Jun": EpochMonth="June";  break;
						case "July": // exists
						case "Jul": EpochMonth="July";  break;
						case "Aug": EpochMonth="August"; break;
						case "Sept": // exists?
						case "Sep": EpochMonth="September"; break;
						case "Oct": EpochMonth="October";  break;
						case "Nov": EpochMonth="November"; break;
						case "Dec": EpochMonth="December"; break;
						default:
							Summary = @"Month: '" + EpochMonth + "' not found!";
							Skip = true;
							break;
					}
					
					string EpochDMY = EpochDay + " " + EpochMonth + " " + EpochYear;
					EpochJD = EpochDMY + @" ([[Julian day|JD]] " + JD + ")";
					OEValStr.Add("epoch", EpochJD);
				}
			}
			
			// prepare to find & store most other OE params
			List<string> OEParameters = new List<string>(new string[]
			{ "eccentricity", "aphelion", "perihelion", "semimajor", "inclination", "asc_node", "arg_peri", "mean_anomaly", "mean_motion" });
			
			foreach (string param in OEParameters)
			{
				switch (param)
				{
					case "eccentricity": OEPatterns.Add(param,    @"\>e\<.+?size\=.2.\>([\d\.Ee\+-]+)\<.+?size\=.2.\>([\d\.n/aEe\+-]+)()\<"); break;
					case "aphelion":     OEPatterns.Add(param,    @"\>Q\<.+?size\=.2.\>([\d\.Ee\+-]+)\<.+?size\=.2.\>([\d\.n/aEe\+-]+)\<.+?size\=.2.\>([a-z/]+)\<"); break;
					case "perihelion":   OEPatterns.Add(param,    @"\>q\<.+?size\=.2.\>([\d\.Ee\+-]+)\<.+?size\=.2.\>([\d\.n/aEe\+-]+)\<.+?size\=.2.\>([a-z/]+)\<"); break;
					case "semimajor":    OEPatterns.Add(param,    @"\>a\<.+?size\=.2.\>([\d\.Ee\+-]+)\<.+?size\=.2.\>([\d\.n/aEe\+-]+)\<.+?size\=.2.\>([a-z/]+)\<"); break;
					case "inclination":  OEPatterns.Add(param,    @"\>i\<.+?size\=.2.\>([\d\.Ee\+-]+)\<.+?size\=.2.\>([\d\.n/aEe\+-]+)\<.+?size\=.2.\>([a-z/]+)\<"); break;
					case "asc_node":     OEPatterns.Add(param, @"\>node\<.+?size\=.2.\>([\d\.Ee\+-]+)\<.+?size\=.2.\>([\d\.n/aEe\+-]+)\<.+?size\=.2.\>([a-z/]+)\<"); break;
					case "arg_peri":     OEPatterns.Add(param, @"\>peri\<.+?size\=.2.\>([\d\.Ee\+-]+)\<.+?size\=.2.\>([\d\.n/aEe\+-]+)\<.+?size\=.2.\>([a-z/]+)\<"); break;
					case "mean_anomaly": OEPatterns.Add(param,    @"\>M\<.+?size\=.2.\>([\d\.Ee\+-]+)\<.+?size\=.2.\>([\d\.n/aEe\+-]+)\<.+?size\=.2.\>([a-z/]+)\<"); break;
					case "mean_motion":  OEPatterns.Add(param,    @"\>n\<.+?size\=.2.\>([\d\.Ee\+-]+)\<.+?size\=.2.\>([\d\.n/aEe\+-]+)\<.+?size\=.2.\>([a-z/]+)\<"); break;
				}
				switch (param) // separated for readability & editability
				{
					case "eccentricity": OEUnitsExpected.Add(param, "");    OESymbols.Add(param, @"\(e\)"); break;
					case "aphelion":     OEUnitsExpected.Add(param, "au");  OESymbols.Add(param, @"\(Q\)"); break;
					case "perihelion":   OEUnitsExpected.Add(param, "au");  OESymbols.Add(param, @"\(q\)"); break;
					case "semimajor":    OEUnitsExpected.Add(param, "au");  OESymbols.Add(param, @"\(a\)"); break;
					case "inclination":  OEUnitsExpected.Add(param, "deg"); OESymbols.Add(param, @"\(i\)"); break;
					case "asc_node":     OEUnitsExpected.Add(param, "deg"); OESymbols.Add(param, @"\(Ω\)"); break;
					case "arg_peri":     OEUnitsExpected.Add(param, "deg"); OESymbols.Add(param, @"\(ω\)"); break;
					case "mean_anomaly": OEUnitsExpected.Add(param, "deg"); OESymbols.Add(param, @"\(M\)"); break;
					case "mean_motion":  OEUnitsExpected.Add(param, "deg/d"); OESymbols.Add(param, @"\(n\)"); break;
				}
			}
			
			// find & store most other OE params
			for (int i = 0; i < OEParameters.Count; i++)
			{
				Param = OEParameters[i];
				string Pattern = OEPatterns[Param];
				Match mPattern = Regex.Match(OrbitalElements, Pattern, RegexOptions.Singleline); // must remain case-sensitive!
				if (mPattern.Success)
				{
					OEValStr.Add(Param, mPattern.Groups[1].Value);
					OEErrors.Add(Param, mPattern.Groups[2].Value);
					OEUnits.Add( Param, mPattern.Groups[3].Value);
					if (OEUnits[ Param] != OEUnitsExpected[Param])
					{
						Summary += @" """ + OEUnitsExpected[Param] + @""" units expected for " + Param + @"; """ + OEUnits[Param] + @""" units received.";
						OEParameters.Remove(Param);
						i--;
					}
				}
				else
				{
					OEParameters.Remove(Param);
					i--;
				}
			}
			
			// find & store "special" OE params
			string Period_Pattern = @"\>period\<.+?size\=.2.\>([\d\.]+)\<br\>([\d\.]+)\<.+?size\=.2.\>([\d\.n/aEe\+-]+)\<br\>([\d\.n/aEe\+-]+)\<.+?size\=.2.\>([a-z]+)\<br\>([a-z]+)\<";
			Match mPeriod = Regex.Match(OrbitalElements, Period_Pattern, RegexOptions.Singleline);
			if (mPeriod.Success)
			{
				OEParameters.Add("PeriodYears"); // years must be added before days
				OEParameters.Add("PeriodDays");  // days must be added after years
				OEValStr.Add("PeriodDays",  mPeriod.Groups[1].Value);
				OEValStr.Add("PeriodYears", mPeriod.Groups[2].Value);
				OEErrors.Add("PeriodDays",  mPeriod.Groups[3].Value);
				OEErrors.Add("PeriodYears", mPeriod.Groups[4].Value);
				OEUnits.Add( "PeriodDays",  mPeriod.Groups[5].Value); // should be "d"
				OEUnits.Add( "PeriodYears", mPeriod.Groups[6].Value); // should be "yr"
				if (OEUnits[ "PeriodDays"]  != "d")  Summary += @" Day units expected for period; """ + OEUnits["PeriodDays"]  + @""" units received.";
				if (OEUnits[ "PeriodYears"] != "yr") Summary += @" Yr units expected for period; """  + OEUnits["PeriodYears"] + @""" units received.";
				if (OEUnits[ "PeriodDays"]  != "d" | OEUnits[ "PeriodYears"] != "yr")
				{
					OEParameters.Remove("PeriodDays");
					OEParameters.Remove("PeriodYears");
				}
			}
			
			// summary skip-condition if any OE units don't match
			if (Summary != OriginalSummary)
			{
				if (skipEntirePageIfAnyJPLUnitsDontMatchExpected) Skip = true;
				else Summary = OriginalSummary;
			}
			
			// Find & store # of sig figs used in infobox for existing parameters. Round up to 5 (similar to JPL's error value precision).
			int j = 0;
			int SumSigFigs = 0;
			double AvgSigFigs = 0;
			foreach (string param in OEParameters)
			{
				j++;
				int SigFigs = 0;
				string Figs = "";
				string FindSigFigs_Pattern = @" *\|\s*" + param + @"\s*=\s*(?:\{\{\s*(?:val|convert)\s*\|\s*)?(\d[\d\.,]*|\.\d+)";
				Match mFindSigFigs = Regex.Match(NewInfobox, FindSigFigs_Pattern, RegexOptions.IgnoreCase);
				if (mFindSigFigs.Success && param != "PeriodDays" && param != "PeriodYears")
					Figs = mFindSigFigs.Groups[1].Value;
				
				// handle period params separately; have to improvise and use JPL's values since:
				// 1) there's no "period_days" parameter, just "period", and
				// 2) someone might've put D before Y or vice versa, so can't trust the 1st number in the |period= parameter
				if (param == "PeriodYears") Figs = OEValStr["PeriodYears"];
				if (param == "PeriodDays")
				{
					// PeriodDays sigfigs = WhichEverIsGreater(JPL # of integer figs, PeriodYears sigfigs + 2)
					Figs = Regex.Replace(OEValStr["PeriodDays"], @"(\d+)\.\d*", @"$1");
					int IntegerFigs = Figs.Length;
					int AdditionalFigs  = (IntegerFigs < 5) ? 2 : 1; // don't want to add too many
					int PeriodYearsFigs = OEWPSigFigs["PeriodYears"] + AdditionalFigs; // "PeriodYears" must be evaluated before "PeriodDays"
					int PeriodDaysFigs  = (IntegerFigs < PeriodYearsFigs) ? PeriodYearsFigs : IntegerFigs;
					
					Figs = new String('9', PeriodDaysFigs);
				}
				
				Figs = Figs.Replace(".", "").Replace(",", "").Trim().TrimStart('0');
				
				if (param == "PeriodYears" |  param == "PeriodDays")
				{
					j--; // PeriodYears is an outlier when it comes to precision; typically only 3 sigfigs,
					SigFigs = Figs.Length; // and PeriodDays is wildly over-precise, so ignore both JPL and WP.
				}
				else if (param != "PeriodYears" && param != "PeriodDays")
				{
					SigFigs = (Figs.Length < 5) ? 5 : Figs.Length; // assume this is good enough (0th iteration)
					
					// If a parameter value doesn't exist, like semimajor for 145534 Jhongda, and all other existing values are >5 sigfigs long,
					// then it looks better and seems more appropriate that semimajor have >5 sigfigs instead of 5, if possible.
					SumSigFigs = SumSigFigs + SigFigs;
					AvgSigFigs = Convert.ToDouble(SumSigFigs) / Convert.ToDouble(j);
					AvgSigFigs = Math.Round(AvgSigFigs);  // use this rounded value as the final
					if (SigFigs < AvgSigFigs)
					{
						SumSigFigs = SumSigFigs - SigFigs + Convert.ToInt32(AvgSigFigs); // remove the assumed value, add the final
						SigFigs = Convert.ToInt32(AvgSigFigs);
					}
				}
				
				OEWPSigFigs.Add(param, SigFigs);
				
				bool debug1 = false;
				if (debug1)
				{
					Summary += param + ": " + j + "," + Figs + "," + Figs.Length + "," + SumSigFigs.ToString() + "," + AvgSigFigs.ToString() + "," + SigFigs.ToString() + "| ";
					Skip = true;
				}
			}
			
			// convert OEValStr from strings to decimals & round to 5 or more significant figures
			foreach (string param in OEParameters)
			{
				// find & store JPL's sigfigs, for comparison later
				string ValStr = OEValStr[param];
				ValStr = ValStr.Replace(".","").Replace(",","").Trim().TrimStart('0');
				OEJPLSigFigs.Add(param, ValStr.Length);
				
				// round roundable params (eccentricity, aphelion, semimajor, perihelion, inclination, asc_node, arg_peri, mean_anomaly, mean_motion, PeriodDays, PeriodYears)
				
				// double doesn't treat trailing decimal 0's as sigfigs (342843 Davidbowie's i should be 2.7680), but decimal DOES
				double OEValue = Convert.ToDouble(OEValStr[param]);
				decimal Scale = Convert.ToDecimal(Math.Pow(10, Math.Floor(Math.Log10(Math.Abs(OEValue))) + 1));
				decimal OERoundedValue = Scale * Math.Round(Convert.ToDecimal(OEValue) / Scale, OEWPSigFigs[param]); // decimal=6 sigfigs, double=5 sigfigs here, for some reason
				OEValues.Add(param, OERoundedValue);
				
				// Remove the UNnecessary trailing zeros (some might be significant).
				// Excessive trailing zeros effects some values, but not all. Not sure why...and I wish there was a cleaner way to fix this...
				string val = OEValues[param].ToString();
				string valnp = val.Replace(".", "").Trim();
				if (valnp.Length > OEWPSigFigs[param])
				{
					int Excess = valnp.Length - OEWPSigFigs[param];
					string Excess0_Pattern = @"0{" + Excess + "}$";
					val = Regex.Replace(val, Excess0_Pattern, "");
					OEValStr[param] = val.Trim('.');
				}
				
				// Pad with significant trailing zeros IIF value is currently below the sigfig threshold
				// AND JPL contains at least that threshold number of sigfigs.
				valnp = val.Replace(".", "").TrimStart('0');
				if (valnp.Length < OEWPSigFigs[param] && OEWPSigFigs[param] <= OEJPLSigFigs[param])
				{
					// This happens if there are trailing significant 0's in the JPL value, which then get removed even if below the 5-digit cutoff,
					// probably b/c I *HAVE TO* make "OEValue" (above) a double, b/c some Math.functions can't accept decimals. It's the 21st century, C#, wtf.
					int Deficit = OEWPSigFigs[param] - valnp.Length;
					string Deficit0s = new String('0', Deficit);
					val += Deficit0s;
					OEValStr[param] = val.Trim('.');
				}
			}
			
			// determine if OE symbols are being used in existing params (& remove backslashes)
			foreach (string param in OEParameters)
			{
				if (param.IndexOf("Period") != -1) continue; // no symbols for PeriodDays & PeriodYears
				
				string Symbol_Pattern = @"\|\s*" + param + @"\s*=[^\r\n]*" + OESymbols[param];
				Match mSymbolExists = Regex.Match(NewInfobox, Symbol_Pattern); // need escapes in symbols here
				OESymbols[param] = OESymbols[param].Replace(@"\", ""); // escapes no longer needed
				if (mSymbolExists.Success) areSymbolsUsed = true;
			}
			
			
			// determine the prevailing infobox spacing scheme ////////////////////
			
			// 4 spacing values: <S1>|<S2><param><S3>=<S4><paramvalue>
			List<int> S12List = new List<int>();
			List<int> S3List  = new List<int>(); 
			List<int> S4List  = new List<int>(); 
			List<int> EqualAlignToList = new List<int>(); // stores the relative pos of "=" for each param found
			
			// name/mp_name/width/background are/should be excluded from search b/c they're more frequently malformed than other params
			List<string> SearchList = AlmostAllParamList; // choose either UpdatableParamList (~27) or AlmostAllParamList (~107)
			foreach (string param in SearchList)
			{
				string Pattern = @"(?<!efn)( *)\|( *)" + param + @"( *)\=( *)([^\r\n\|]{4,})?"; // want non-empty 1-line params
				Match mPattern = Regex.Match(NewInfobox, Pattern);
				if (mPattern.Success)
				{
					S1 = mPattern.Groups[1].Value + " "; // >= 1 space needed so there are no leading zeros, which might be trucated.
					S2 = mPattern.Groups[2].Value + " "; // Will subtract 1 from these values later.
					string S12_temp = S1.Length.ToString() + S2.Length.ToString();
					S12List.Add(Convert.ToInt32(S12_temp));
					
					// handle S3 & EqualAlignTo separately since they're related & vary differently than S12
					S3 = mPattern.Groups[3].Value;
					if (S3.Length > 2 | param.Length > 10) EqualAlignTo = param.Length + S3.Length;
					else EqualAlignTo = 0; // pos of "=" relative to start of parameter name
					
					S3List.Add(S3.Length);
					EqualAlignToList.Add(EqualAlignTo);
					
					// handle S4 separately, only for non-empty params, since empty params only count towards S123
					S4 = mPattern.Groups[4].Value;
					if (mPattern.Groups[5].Value.Trim().Length >= 4 | S4.Length > 0)
					{
						if (S4.Length == 2) S4 = " "; // "=  " is weird, and probably a typo too
						S4List.Add(S4.Length);
					}
					else S4 = "";
					
					//NewInfobox += " " + param + ":" + S12_temp + S3.Length.ToString() + S4.Length.ToString() + @"+" + EqualAlignTo.ToString(); // debugging
				}
			}
			
			// figure out which values are the most common
			int MostCommonS12 = (from i in S12List // stackoverflow.com ftw!
										group i by i into grp
										orderby grp.Count() descending
										select grp.Key).First();
			
			int MostCommonS3 = (from i in S3List
									  group i by i into grp
									  orderby grp.Count() descending
									  select grp.Key).First();
			
			int MostCommonS4 = (from i in S4List
									  group i by i into grp
									  orderby grp.Count() descending
									  select grp.Key).First();
									  
			EqualAlignTo = (from i in EqualAlignToList
								 group i by i into grp
								 orderby grp.Count() descending
								 select grp.Key).First();
			// rule out any alignment IIF EqualAlignTo frequency < 40% AND MostCommonS3 < 3
			int EqualAlignTo_Count = ((from temp in EqualAlignToList where temp.Equals(EqualAlignTo) select temp).Count());
			double EqualAlignTo_Fraction = Convert.ToDouble(EqualAlignTo_Count) / Convert.ToDouble(EqualAlignToList.Count);
			if (EqualAlignTo_Fraction < 0.4 && MostCommonS3 < 3) EqualAlignTo = 0;
			
			// store remaining spacing scheme
			string SpacingIndex = MostCommonS12.ToString();
			int MostCommonS1 = Convert.ToInt32(SpacingIndex.Substring(0, 1)) - 1;
			int MostCommonS2 = Convert.ToInt32(SpacingIndex.Substring(1, 1)) - 1;
			S1 = new String(' ', MostCommonS1);
			S2 = new String(' ', MostCommonS2);
			S4 = new String(' ', MostCommonS4);
			if (MostCommonS3 == 2) S3 = " "; // 2 spaces is most likely a bug/typo for 1 space, if ubiquitous
			else S3 = new String(' ', MostCommonS3);
			S12 = S1 + "|" + S2;
			
			bool debug2 = false;
			if (debug2)
			{
				NewInfobox += "\n Most common S1, 2, 3, 4 lengths:" + MostCommonS1.ToString() + ", " +
									MostCommonS2.ToString() + ", " + MostCommonS3.ToString() + ", " + MostCommonS4.ToString();
				NewInfobox += "\n EqualAlignTo length:" + EqualAlignTo.ToString();
				NewInfobox += "\n EqualAlignTo_Count: " + EqualAlignTo_Count.ToString();
				NewInfobox += "\n EqualAlignTo_Fraction:" + EqualAlignTo_Fraction.ToString();
			}
			
			
			// add/update {{Infobox}} OE params ///////////////////////////////////
			
			Param = "discovered";
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= Param.Length) ? new String(' ', EqualAlignTo - Param.Length) : "";
			string OldParam = @" *\|\s*" + Param + @"\s*=[^\r\n\<]*";
			string NewUnits = "";
			string NewParam = S12 + Param + S3 + "=" + S4 + JPL_DDate;
			Match mParam = Regex.Match(NewInfobox, OldParam);
			if ( mParam.Success && !string.IsNullOrEmpty(JPL_DDate)) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
			if (!mParam.Success && !string.IsNullOrEmpty(JPL_DDate)) NewInfobox = rAppendToInfobox.Replace(NewInfobox, @"$1" + NewParam + "\n" + @"$2");
			
			Param = "minorplanet"; // insert @ top
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= Param.Length) ? new String(' ', EqualAlignTo - Param.Length) : "";
			OldParam = @" *\|\s*" + Param + @"\s*=[^\r\n\<]*";
			NewParam = S12 + Param + S3 + "=" + S4 + "yes";
			string AppendParam = @"{{Infobox planet" + "\n" + NewParam;
			mParam = Regex.Match(NewInfobox, OldParam);
			if ( mParam.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
			if (!mParam.Success) NewInfobox = Regex.Replace(NewInfobox, @"{{Infobox planet", AppendParam);
			
			// remove deprecated OE parameters, unless they end with "<!--" (i.e. [[6398 Timhunter]])
			List<string> DeprecatedParams = new List<string>(new string[]
				{ "physical_characteristics", "orbital_characteristics", "designations", "discovery", "width" , "diameter" });
			int Deleted = 0;
			foreach (string param in DeprecatedParams)
			{
				string DeleteCandidate_Pattern = @"[\r\n]+ *\|\s*" + param + @"\s*=[^\r\n]*";
				Match mDeleteCandidate = Regex.Match(NewInfobox, DeleteCandidate_Pattern, RegexOptions.IgnoreCase);
				if (mDeleteCandidate.Success)
				{
					string CommentElement_Pattern = @"(\<\!\-\-|\-\-\>)";
					Match mCommentElement = Regex.Match(mDeleteCandidate.Value, CommentElement_Pattern);
					
					string MultilineComment_Pattern = @"\<\!\-\-[   ]*" + Environment.NewLine;
					Match mMultilineComment = Regex.Match(mDeleteCandidate.Value, MultilineComment_Pattern);
					
					string CommentSelfContained_Pattern = @"(\<\!\-\-[^\r\n]*\-\-\>)";
					Match mCommentSelfContained = Regex.Match(mDeleteCandidate.Value, CommentSelfContained_Pattern);
					
					bool okDelete1 = !mCommentElement.Success;
					bool okDelete2 = (mCommentElement.Success && mCommentSelfContained.Success && !mMultilineComment.Success);
					if (okDelete1 | okDelete2)
					{
						Deleted++;
						NewInfobox = Regex.Replace(NewInfobox, DeleteCandidate_Pattern, "", RegexOptions.IgnoreCase);
					}
				}
			}
			if (Deleted > 0)
			{
				string Plural = (Deleted > 1) ? "s" : "";
				Summary += @"; remove " + Deleted.ToString() + @" deprecated parameter" + Plural;
			}
			
			// bgcolour (deprecated) -> background
			Param = @"bgcolu?ou?r";
			OldParam = @" *\|\s*" + Param + @"\s*= *([^\r\n\<]*)"; 
			Param = "background";
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= Param.Length) ? new String(' ', EqualAlignTo - Param.Length) : "";
			NewParam = S12 + Param + S3 + "=" + S4 + @"${1}"; // don't modify bg color (see [[User:Rfassbind/sandbox/color-scheme]])
			mParam = Regex.Match(NewInfobox, OldParam);
			if (mParam.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
			
			// |background= handling
			Param = "background";
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= Param.Length) ? new String(' ', EqualAlignTo - Param.Length) : "";
			OldParam = @" *\|\s*" + Param + @"\s*=[^\r\n\<]*";
			NewParam = S12 + Param + S3 + "=" + S4 + @"#FFFFC0";
			mParam = Regex.Match(NewInfobox, OldParam);
			if (mParam.Success)
			{
				// if background != "#<3-6-digit hexidecimal>", make background=#FFFFC0
				string OldParamColor_Pattern = @"(#[0-9A-Fa-f]{3,6})(?![0-9A-Fa-f])";
				Match mOldParamColor = Regex.Match(mParam.Value, OldParamColor_Pattern);
				if  (!mOldParamColor.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
				else ; // do nothing: don't modify bg color, see [[User:Rfassbind/sandbox/color-scheme]] instead
			}
			if (!mParam.Success)
			{
				// insert "background=#FFFFC0" after |minorplanet=yes if background DNE
				NewInfobox = Regex.Replace(NewInfobox, @" *\|\s*minorplanet\s*=[^\r\n\<]*", @"$0" + "\n" + NewParam);
			}
			
			Param = "epoch";
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= Param.Length) ? new String(' ', EqualAlignTo - Param.Length) : "";
			OldParam = @" *\|\s*" + Param + @"\s*=[^\r\n\<]*";
			NewParam = S12 + Param + S3 + "=" + S4 + OEValStr[Param];
			mParam = Regex.Match(NewInfobox, OldParam);
			if ( mParam.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
			if (!mParam.Success) NewInfobox = rAppendToInfobox.Replace(NewInfobox, @"$1" + NewParam + "\n" + @"$2");
			
			foreach (string param in OEParameters)
			{
				// evaluate error (display if > 1)
				double Error = -1d;
				Match mIsNum = Regex.Match(OEErrors[param].Trim(), @"^[\d\.Ee\+\-,]+$");
				if (mIsNum.Success) Error = Convert.ToDouble(OEErrors[param].Trim());
				
				// evaluate suffix
				double AU = 0d; // convert to Gm or Tm?
				if (param == "aphelion" | param == "semimajor" | param == "perihelion") AU = Convert.ToDouble(OEValStr[param].Trim());
				string ConvertSuffix = (AU < 6.68459d) ? @"Gm|abbr=on" : @"Tm|abbr=on";
				
				if (param == "mean_motion") // (n) handle separately from other OEParams
				{
					// evaluate mm value
					double MM = Convert.ToDouble(OEValStr[param].Trim());
					if (MM < 1d) OEValStr[param] = @"{{Deg2DMS|" + OEValStr[param] + @"|sup=ms}}";
					
					// evaluate mm error (display if > MM/2)
					if (Error >= (MM/2d))
					{
						if (Error <  1d) OEValStr[param] += @" ± {{Deg2DMS|" + OEErrors[param] + @"|sup=ms}}";
						if (Error >= 1d) OEValStr[param] += @" ± " + OEErrors[param];
					}
					
					// evaluate mm units
					if (MM < 1d | (Error >= (MM/2d) && Error < 1d)) OEUnits[param] = @" / day";
					else OEUnits[param] = @"°/day";
				}
				
				// reuse OEUnits & OEValStr lists to customize each value displayed
				switch (param)
				{
					// {{Convert|1.23456|AU|Gm/Tm}} params
					case "aphelion": // (Q)
						if (Error >= 1d) OEValStr[param] = @"{{Convert|" + OEValStr[param] + "|±|" + OEErrors[param] + "|" + OEUnits[param].ToUpper() + "|" + ConvertSuffix + @"|lk=on}}";
						if (Error <  1d) OEValStr[param] = @"{{Convert|" + OEValStr[param] + "|" + OEUnits[param].ToUpper() + "|" + ConvertSuffix + @"|lk=on}}";
											  OEUnits[ param] = @""; break;
					case "semimajor": // (a)
						if (Error >= 1d) OEValStr[param] = @"{{Convert|" + OEValStr[param] + "|±|" + OEErrors[param] + "|" + OEUnits[param].ToUpper() + "|" + ConvertSuffix + @"}}";
						if (Error <  1d) OEValStr[param] = @"{{Convert|" + OEValStr[param] + "|" + OEUnits[param].ToUpper() + "|" + ConvertSuffix + @"}}";
											  OEUnits[ param] = @""; break;
					case "perihelion": // (q)
						if (Error >= 1d) OEValStr[param] = @"{{Convert|" + OEValStr[param] + "|±|" + OEErrors[param] + "|" + OEUnits[param].ToUpper() + "|" + ConvertSuffix + @"}}";
						if (Error <  1d) OEValStr[param] = @"{{Convert|" + OEValStr[param] + "|" + OEUnits[param].ToUpper() + "|" + ConvertSuffix + @"}}";
											  OEUnits[ param] = @""; break;
					
					case "PeriodDays":
					case "PeriodYears": continue; // skip these & handle them after the foreach loop
				}
				
				// {{val}} params & (conditional) units based on large errors (separated for readability & editability) (i.e. 2014 MT69)
				switch (param)
				{
					case "eccentricity": // (e)
						if (Error >= 1d) OEValStr[param] = @"{{val|" + OEValStr[param] + "|" + OEErrors[param] + @"}}";
						OEUnits[param] = @""; break;
					
					case "inclination":  // (i)
					case "asc_node":     // (node)
					case "arg_peri":     // (peri)
						if (Error >= 1d)
						{
							OEValStr[param] = @"{{val|" + OEValStr[param] + "|" + OEErrors[param] + @"|u=°}}";
							OEUnits[param] = @"";
						}
						else OEUnits[param] = @"°";
						break;
					
					case "mean_anomaly": // (M)
						if (Error >= Convert.ToDouble(OEValStr[param])) OEValStr[param] = @"{{val|" + OEValStr[param] + "|" + OEErrors[param] + @"}}";
						OEUnits[param] = @"[[Degree (angle)|°]]"; break; // unit's first use in the rendered infobox
				}
				
				// add/append OE parameters & values
				if (EqualAlignTo > 0) S3 = (EqualAlignTo >= param.Length) ? new String(' ', EqualAlignTo - param.Length) : "";
				OldParam = @" *\|\s*" + param + @"\s*=[^\r\n\<]*";
				string NewSymbol = (areSymbolsUsed) ? " " + OESymbols[param] : "";
				NewParam = S12 + param + S3 + "=" + S4 + OEValStr[param] + OEUnits[param] + NewSymbol;
				mParam = Regex.Match(NewInfobox, OldParam);
				if ( mParam.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
				if (!mParam.Success) NewInfobox = rAppendToInfobox.Replace(NewInfobox, @"$1" + NewParam + "\n" + @"$2");
				
			} // end foreach (string param in OEParameters)
			
			Param = "period";
			if (OEValStr.ContainsKey("PeriodYears"))
			{
				if (EqualAlignTo > 0) S3 = (EqualAlignTo >= Param.Length) ? new String(' ', EqualAlignTo - Param.Length) : "";
				OldParam = @" *\|\s*" + Param + @"\s*=[^\r\n\<]*";
				string NewUnits_yr = @" [[Julian year (astronomy)|yr]]";
				string NewUnits_d  = @" [[Julian year (astronomy)|d]]"; // best description of a Julian day, as used here, is at the top of [[Julian year]]
				
				// build NewParam & handle large errors (don't include days if error >= period/2)
				double PYears    = Convert.ToDouble(OEValStr["PeriodYears"]);
				double PYearsErr = Convert.ToDouble(OEErrors["PeriodYears"]);
				if (PYearsErr >= (PYears/2d))
					  NewParam = S12 + Param + S3 + "=" + S4 + "{{val|" + PYears.ToString() + "|" + PYearsErr.ToString() + @"}}" + NewUnits_yr;
				else NewParam = S12 + Param + S3 + "=" + S4 + OEValStr["PeriodYears"] + NewUnits_yr + " (" + OEValStr["PeriodDays"] + NewUnits_d + ")";
				
				// add/update period
				mParam = Regex.Match(NewInfobox, OldParam);
				if ( mParam.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
				if (!mParam.Success) NewInfobox = rAppendToInfobox.Replace(NewInfobox, @"$1" + NewParam + "\n" + @"$2");
			}
			
			// figure out which ref to use in |orbit_ref=, if/when needed
			JPLDataRef_MasterOrSlave = (jplDataMasterExists) ? JPLDataRef_Slave : JPLDataRef_Master;
			
			// make sure that "|orbit_ref=" contains a ref with "jpl" in the name
			Param = "orbit_ref";
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= Param.Length) ? new String(' ', EqualAlignTo - Param.Length) : "";
			
			string OrbitRef_Pattern = @" *\|\s*orbit_ref\s*= *([^\r\n]*(?:\{\{cit[ae][ t][^\}]+\}\}(?:\s*\</ref\>)?)?)"; // "?" in case not on a sep line & Environment.NewLine doesn't work here for some reason
			Match mOrbitRef = Regex.Match(NewInfobox, OrbitRef_Pattern, RegexOptions.IgnoreCase);
			if (mOrbitRef.Success) // "orbit_ref" exists, but it could either be 1) empty, 2) have a JPL ref, or 3) have no JPL refs
			{
				string OrbitRef = mOrbitRef.Groups[1].Value;
				if (!string.IsNullOrEmpty(OrbitRef)) // not empty
				{
					string OrbitRefRef_Pattern = @" *\|\s*orbit_ref\s*=\s*.*?\<ref";
					Match mOrbitRefRef = Regex.Match(NewInfobox, OrbitRefRef_Pattern, RegexOptions.IgnoreCase);
					if (mOrbitRefRef.Success) // orbit_ref has a ref
					{
						string OrbitRefJPLRef_Pattern = @" *\|\s*orbit_ref\s*=\s*(.*?\<ref name\s*=\s*[^\r\n\>/]*?(?:" + JPLRefNameVariants + @")[^\r\n\>]*/?\>[^\r\n]*?)";
						Match mOrbitRefJPLRef = Regex.Match(NewInfobox, OrbitRefJPLRef_Pattern, RegexOptions.IgnoreCase);
						if ( mOrbitRefJPLRef.Success); // it's jpl; do nothing
						if (!mOrbitRefJPLRef.Success) // it's not jpl; append jplref
						{
							NewParam = S12 + Param + S3 + "=" + S4 + @"$1" + JPLDataRef_MasterOrSlave;// + "\n";
							NewInfobox = Regex.Replace(NewInfobox, OrbitRef_Pattern, NewParam, RegexOptions.IgnoreCase);
							if (!jplDataMasterExists) Summary += "; +jpldata master ref to orbit_ref";
							jplDataMasterExists = true;
						}
					}
					if (!mOrbitRefRef.Success) // orbit_ref has no refs; replace text with jplref
					{
						NewParam = S12 + Param + S3 + "=" + S4 + ThinspRefs + JPLDataRef_MasterOrSlave;// + "\n";
						NewInfobox = Regex.Replace(NewInfobox, OrbitRef_Pattern, NewParam, RegexOptions.IgnoreCase);
						if (!jplDataMasterExists) Summary += "; +jpldata master ref to orbit_ref";
						jplDataMasterExists = true;
					}
				}
				if (string.IsNullOrEmpty(OrbitRef)) // orbit_ref is empty; add jplref
				{
					NewParam = S12 + Param + S3 + "=" + S4 + ThinspRefs + JPLDataRef_MasterOrSlave;// + "\n";
					NewInfobox = Regex.Replace(NewInfobox, OrbitRef_Pattern, NewParam, RegexOptions.IgnoreCase);
					if (!jplDataMasterExists) Summary += "; +jpldata master ref to orbit_ref";
					jplDataMasterExists = true;
				}
			}
			else if (!mOrbitRef.Success) // "orbit_ref" DNE; append Param + ref to infobox
			{
				NewParam = S12 + Param + S3 + "=" + S4 + ThinspRefs + JPLDataRef_MasterOrSlave;
				NewInfobox = rAppendToInfobox.Replace(NewInfobox, @"$1" + NewParam + "\n" + @"$2");
				if (!jplDataMasterExists) Summary += "; +jpldata master ref to orbit_ref";
				jplDataMasterExists = true;
			}
			
			bool debug3 = false;
			if (debug3)
			{
				// see https://en.wikipedia.org/w/index.php?title=User:Tom.Reding/JPL_to_Infobox_planet&oldid=718933095
				// for OEParameters, OEValStr, & OEWPSigFigs debugging display
			}
			
		}
	} // end Orbital Elements Table
	
	
	// Orbit Determination Parameters -> Infobox ////////////////////////////////
	
	// isolate the "Orbit Determination Parameters" table & save components
	string ODParameters_Pattern = @"Orbit\s+Determination\s+Parameters.+?\</table\>";
	Match mODParameters = Regex.Match(JPL_ExternalText, ODParameters_Pattern, RegexOptions.Singleline);
	if (mODParameters.Success && !Skip)
	{
		string ODParameters = mODParameters.Value;
		
		Param = "observation_arc";
		string ObsArc_Pattern = @"\>data\-arc span\<.+?size\=""2""\>&nbsp;&nbsp;(([\d\.,]+) days \(([\d\.]+) yr\))&nbsp;&nbsp;\<";
		Match mObsArc = Regex.Match(ODParameters, ObsArc_Pattern, RegexOptions.Singleline); // WL obsarc 1st, period 2nd
		if (mObsArc.Success)
		{
			string ObsArc   = mObsArc.Groups[1].Value;
			string ObsDays  = mObsArc.Groups[2].Value.Trim('.');
			string ObsYears = mObsArc.Groups[3].Value.Trim('.');
			
			// if >= 365 days, format: "years (days)", otherwise default to JPL's "days (years)"
			int iObsDays = Convert.ToInt32(ObsDays);
			if (iObsDays >= 365) ObsArc = ObsYears + @" yr (" + ObsDays + @" d)";
			else ObsArc = Regex.Replace(ObsArc, "days?", "d", RegexOptions.IgnoreCase);
			
			// add to/update infobox
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= Param.Length) ? new String(' ', EqualAlignTo - Param.Length) : "";
			string OldParam = @" *\|\s*" + Param + @"\s*=[^\r\n\<]*";
			string NewParam = S12 + Param + S3 + "=" + S4 + ObsArc;
			Match mParam = Regex.Match(NewInfobox, OldParam);
			if ( mParam.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
			if (!mParam.Success) NewInfobox = rAppendToInfobox.Replace(NewInfobox, @"$1" + NewParam + "\n" + @"$2");
		}
		
		Param = "uncertainty";
		string CCode_Pattern = @"\>condition\s+code\<.+?size\=""2""\>&nbsp;&nbsp;(\d)&nbsp;&nbsp;\<";
		Match mCCode = Regex.Match(ODParameters, CCode_Pattern, RegexOptions.Singleline);
		if (mCCode.Success)
		{
			string CCode = mCCode.Groups[1].Value;
			
			// add to/update infobox
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= Param.Length) ? new String(' ', EqualAlignTo - Param.Length) : "";
			string OldParam = @" *\|\s*" + Param + @"\s*=[^\r\n\<]*";
			string NewParam = S12 + Param + S3 + "=" + S4 + CCode;
			Match mParam = Regex.Match(NewInfobox, OldParam);
			if ( mParam.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
			if (!mParam.Success) NewInfobox = rAppendToInfobox.Replace(NewInfobox, @"$1" + NewParam + "\n" + @"$2");
		}
	} // end Orbit Determination Parameters
	
	
	// Physical Parameters Table -> Infobox /////////////////////////////////////
	
	// declare regionals
	Dictionary<string, string> PPValues   = new Dictionary<string, string>(); // raw-ish JPL values
	Dictionary<string, string> PPValWP    = new Dictionary<string, string>(); // "WP-ready" template-wrapped values
	Dictionary<string, string> PPErrors   = new Dictionary<string, string>(); // raw JPL values
	Dictionary<string, string> PPErrWP    = new Dictionary<string, string>(); // "WP-ready" values, depending on if consumed by {{Convert/val}}
	Dictionary<string, string> PPPatterns = new Dictionary<string, string>(); // regex patterns needed to find values on JPL's website
	Dictionary<string, string> PPUnits    = new Dictionary<string, string>(); // raw JPL's units
	Dictionary<string, string> PPUnitsWP  = new Dictionary<string, string>(); // units to be displayed in {{Infobox}}
	Dictionary<string, string> PPUnitsExpected = new Dictionary<string, string>();
	
	// isolate the "Physical Parameters Table" & save components
	string PhysicalParameters_Pattern = @"Physical\s+Parameter\s+Table.+?\</table\>";
	Match mPhysicalParameters = Regex.Match(JPL_ExternalText, PhysicalParameters_Pattern, RegexOptions.Singleline);
	if (mPhysicalParameters.Success && !Skip)
	{
		string PhysicalParameters = mPhysicalParameters.Value;
		
		// prepare to find & store most Physical Parameters
		List<string> PParameters = new List<string>(new string[] { "abs_magnitude", "mass", "rotation", "albedo" }); // do dimensions later
		foreach (string param in PParameters)
		{
			switch (param)
			{
				case "abs_magnitude": PPPatterns.Add(param, @"\>absolute magnitude\<.+?size\=""2""\>([\d\.]+)\<.+?size\=""2""\>([a-z]+)\<.+?size\=""2""\>(n/a|[\d\.Ee\+-]+)\<"); break;
				case "mass"    : PPPatterns.Add(param,               @"\>GM\<.+?size\=""2""\>([\d\.Ee\+-]+)\<.+?size\=""2""\>([\w\^/]+)\<.+?size\=""2""\>(n/a|[\d\.Ee\+-]+)\<"); break;
				case "rotation": PPPatterns.Add(param,  @"\>rotation period\<.+?size\=""2""\>([\d\.]+)\<.+?size\=""2""\>(h)\<.+?size\=""2""\>(n/a|[\d\.Ee\+-]+)\<"); break;
				case "albedo"  : PPPatterns.Add(param, @"\>geometric albedo\<.+?size\=""2""\>([\d\.]+)\<.+?size\=""2""\>([^\<]+)\<.+?size\=""2""\>(n/a|[\d\.Ee\+-]+)\<"); break;
			}
			switch (param) // separated for readability & editability
			{
				case "abs_magnitude": PPUnitsExpected.Add(param, @"mag");      PPUnitsWP.Add(param, @""); break; // Preassign desired unit-display, in case all goes well.
				case "mass"         : PPUnitsExpected.Add(param, @"km^3/s^2"); PPUnitsWP.Add(param, @" kg"); break; // They won't get called unless the associated parm remains
				case "rotation"     : PPUnitsExpected.Add(param, @"h");        PPUnitsWP.Add(param, @""); break; // in PParameters as "good". Otherwise removed.
				case "albedo"       : PPUnitsExpected.Add(param, @"&nbsp;");   PPUnitsWP.Add(param, @""); break;
			}
		}
		
		// find & store most Physical Parameters
		for (int i = 0; i < PParameters.Count; i++)
		{
			Param = PParameters[i];
			string Pattern = PPPatterns[Param];
			Match mPattern = Regex.Match(PhysicalParameters, Pattern, RegexOptions.Singleline);
			if (mPattern.Success)
			{
				PPValues.Add(Param, mPattern.Groups[1].Value);
				PPValWP.Add( Param, mPattern.Groups[1].Value);
				PPUnits.Add( Param, mPattern.Groups[2].Value);
				PPErrors.Add(Param, mPattern.Groups[3].Value); // never changed
				PPErrWP.Add( Param, mPattern.Groups[3].Value); // changed to "n/a" if/when consumed by {{Convert/val}}
				
				string LeadingZero = (PPErrWP[Param].Substring(0,1) == ".") ? "0" : "";
				PPErrWP[Param] = LeadingZero + PPErrWP[Param];
				
				if (PPUnits[Param] != PPUnitsExpected[Param])
				{
					PParameters.Remove(Param);
					if (skipEntirePageIfAnyJPLUnitsDontMatchExpected)
					{
						Summary += @" """ + PPUnitsExpected[Param] + @""" units expected for " + Param + @"; """ + PPUnits[Param] + @""" units received.";
						Skip = true;
					}
					i--;
				}
				else if (Param == "rotation")
				{
					PPValWP[Param] = PPValues[Param] = PPValWP[Param].Trim('.');
					double RotTime = Convert.ToDouble(PPValues[Param]);
					double OneMinute = (1d/60d); // in hours
					string DaysMinSec = "d";
					if (RotTime < 1) DaysMinSec = (RotTime < OneMinute) ? "s" : "min";
					if (PPErrWP[Param] == "n/a") PPValWP[Param] = @"{{Convert|" + PPValWP[Param] + @"|h|" + DaysMinSec + "|abbr=on|lk=on}}";
					if (PPErrWP[Param] != "n/a")
					{
						PPValWP[Param] = @"{{Convert|" + PPValWP[Param] + @"|±|" + PPErrWP[Param] + @"|h|" + DaysMinSec + "|abbr=on|lk=on}}";
						PPErrWP[Param] = "n/a"; // "n/a" ensures it won't accidentally be displayed later
					}
				}
				else if (Param == "albedo" | Param == "abs_magnitude")
				{
					PPValWP[Param] = PPValues[Param] = PPValWP[Param].Trim('.');
					if (PPErrWP[Param] == "n/a") ; // do nothing; just display the bare value
					if (PPErrWP[Param] != "n/a")
					{
						PPValWP[Param] = @"{{val|" + PPValWP[Param] + @"|" + PPErrWP[Param] + @"}}";
						PPErrWP[Param] = "n/a"; // "n/a" ensures it won't accidentally be displayed later
					}
				}
				
			}
			else if (!mPattern.Success)
			{
				PParameters.Remove(Param);
				i--;
			}
		} // end for()
		
		// find & store remaining Physical Parameters that need to be modified (diameter or extent -> dimensions)
		
		string Extent_Pattern = @"\>extent\<.+?size\=""2""\>([\d\.x]+)\<.+?size\=""2""\>(k?m)\<.+?size\=""2""\>(n/a|[\d\.Ee\+-]+)\<";
		Match mExtent = Regex.Match(PhysicalParameters, Extent_Pattern, RegexOptions.Singleline);
		
		string Diameter_Pattern = @"\>diameter\<.+?size\=""2""\>([\d\.]+)\<.+?size\=""2""\>(k?m)\<.+?size\=""2""\>(n/a|[\d\.Ee\+-]+)\<";
		Match mDiameter = Regex.Match(PhysicalParameters, Diameter_Pattern, RegexOptions.Singleline);
		
		// use "extent" instead of "diameter", if possible
		Param = "dimensions";
		if (mDiameter.Success && !mExtent.Success)
		{
			PParameters.Add(Param);
			PPValues.Add( Param, mDiameter.Groups[1].Value);
			PPValWP.Add(  Param, mDiameter.Groups[1].Value);
			PPUnits.Add(  Param, mDiameter.Groups[2].Value); // "km" or "m"
			PPUnitsWP.Add(Param, "");
			PPErrors.Add( Param, mDiameter.Groups[3].Value); // never changed to "n/a"
			PPErrWP.Add(  Param, mDiameter.Groups[3].Value); // changed to "n/a" if/when consumed by {{Convert/val}}
		}
		else if (mExtent.Success)
		{
			PParameters.Add(Param);
			PPValWP.Add(  Param, mExtent.Groups[1].Value.Replace('x', '×')); // 1x2x3 -> 1×2×3 km
			PPUnits.Add(  Param, mExtent.Groups[2].Value); // "km" or "m"
			PPUnitsWP.Add(Param, "");
			PPErrors.Add( Param, mExtent.Groups[3].Value); // never changed
			PPErrWP.Add(  Param, mExtent.Groups[3].Value); // changed to "n/a" if/when consumed by {{Convert}}
		}

		if (mDiameter.Success | mExtent.Success)
		{
			// check units
			if      (PPUnits[Param] == "km") PPUnitsWP[Param] = @" [[Kilometre|km]]";
			else if (PPUnits[Param] ==  "m") PPUnitsWP[Param] = @" [[Metre|m]]";
			else
			{
				PParameters.Remove(Param);
				if (skipEntirePageIfAnyJPLUnitsDontMatchExpected)
				{
					Summary += " km or m units expected for " + Param + @"; """ + PPUnits[Param] + @""" units received.";
					Skip = true;
				}
			}
			
			// evaluate error
			if (PPErrors[Param] != "n/a" && !string.IsNullOrEmpty(PPErrors[Param]))
			{
				PPValWP[Param] = @"{{val|" + PPValWP[Param] + @"|" + PPErrWP[Param] + @"|ul=" + PPUnits[Param] + @"}}";
				PPErrWP[Param] = "n/a"; // "n/a" ensures it won't accidentally be displayed later
				PPUnitsWP[Param] = "";
			}
		}
		
		// no reason to round Physical Parameter Table values, since they all have a small number of figs
		
		
		// add/update {{Infobox}} Physical Parameters ////////////////////////////
		foreach (string param in PParameters)
		{
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= param.Length) ? new String(' ', EqualAlignTo - param.Length) : "";
			string S1234 = S12 + param + S3 + @"=" + S4;
			
			if (param == "mass")
			{
				// calculate mass
				decimal G  = 0.0000000000667408m; // 6.7408e-11 m^3 kg^-1 s^-2
				decimal GM = Convert.ToDecimal(PPValWP[param]);
				decimal ConversionFactor = Convert.ToDecimal(Math.Pow(10.0, 9)); // GM = km^3/s^2 = 1e9 m^3/s^2
				decimal M = GM * ConversionFactor / G; // GM = km^3/s^2 = 1e9 m^3/s^2
				
				// format mass
				string NewValue = M.ToString("e2"); // "1.23e+020"
				Match mNewValue = Regex.Match(NewValue, @"([\d\.]+)[Ee][\+-]0(\d\d)");
				NewValue = mNewValue.Groups[1].Value + @" {{e|" + mNewValue.Groups[2].Value + @"}}"; // "1.23 {{e|20}}"
				PPValWP["mass"] = NewValue;
			}
			
			if (param == "mass" | param == "abs_magnitude" | param == "rotation" | param == "albedo" | param == "dimensions")
			{
				bool PrependJPLRefs = true; // append or prepend jpldata to parameter (JPL is usually ref #1, so default to prepend)
				string OldParamFull = @" *\|\s*" + param + @"\s*=[^\r\n]*";
				string OldParam     = @" *\|\s*" + param + @"\s*=[^\r\n\<]*";
				string NewErrWP = (PPErrWP[param] != "n/a") ? " ± " + PPErrWP[param] : ""; // display only, not for comparison
				string NewParam = S1234 + PPValWP[param] + NewErrWP + PPUnitsWP[param]; // display only, not for comparison
				string NewValErr = PPValues[param].Trim() + @" " + PPErrors[param].Trim().Replace("n/a", ""); // comparison only, not for display
				string NewValErr_Pattern = PPValues[param].Trim() + @"[\s\+\-±\|]*" + PPErrors[param].Trim().Replace("n/a", ""); // comparison only, not for display
				string NewRef = @"<ref name=" + RefName_jpl + @"/>";
				Match mOldParamFull = Regex.Match(NewInfobox, OldParamFull);
				NewValErr = NewValErr.Trim();
				
				// abs_mag, rotation, etc. seem to frequently contain 1 or more non-jpl refs. Append/update JPL val and/or ref depending on what we find.
				string AbsMagRef_Pattern = @" *\|\s*" + param + @"\s*= *([^\r\n]+)([, ]*)( *\<ref[^\<]*?(?:\</ref\>|/?\>)[^\r\n]*?)"; // 3 groups; preserve unicode &thinsp; before <ref>
				Match mAbsMagRef = Regex.Match(NewInfobox, AbsMagRef_Pattern, RegexOptions.IgnoreCase);
				if (mAbsMagRef.Success) // ref(s) exist; dig deeper
				{
					// to do: even more preliminary...way earlier in the code, I need to move jpl master refs from display-parameters to orbit_ref, physical_ref, etc...
					// wait til physical_ref is a parameter
					
					// preliminary screening: for cases when jplref and another refvalue needs updating, but has multiple refs, one of which is jplref, then remove jplref and proceed as normal
					string AbsMagJPLRefAnywhere_Pattern = @" *\|\s*" + param + @"\s*= *(.*?)([  ]*\<ref name\s*=\s*[^/\>]*(?:" + JPLRefNameVariants + @")[^/\>]*)"; // 2 groups; preserve leading spaces
					Match mAbsMagJPLRefAnywhere = Regex.Match(NewInfobox, AbsMagJPLRefAnywhere_Pattern, RegexOptions.IgnoreCase);
					if (mAbsMagJPLRefAnywhere.Success) // jplref exists; if it's adjacent to another ref, remove jplref
					{
						// needs to account for: <ref>...</ref>, <ref name="blah">...</ref>, <ref name="blah"/>, & {{efn}} for non-jpl masters. 4 groups each.
						// 324 Bamberga was a good test case: can't see past multiline refs, yet
						string AdjaRefLeft  = @"( *\|\s*" + param + @"\s*=[^\r\n]*?)(\<ref.+?(?:/\>|/ref\>)|\{\{\s*(?:efn)[^\}]+\}\})([  ]*)(\<ref name\s*=\s*[^/\>]*(?:" + JPLRefNameVariants + @")[^/\>]*/\>)";
						string AdjaRefRight = @"( *\|\s*" + param + @"\s*=[^\r\n]*?)(\<ref name\s*=\s*[^/\>]*(?:" + JPLRefNameVariants + @")[^/\>]*/\>)([  ]*)(\<ref.+?(?:/\>|/ref\>)|\{\{\s*(?:efn)[^\}]+\}\})";
						
						Match mAdjaRefLeft  = Regex.Match(NewInfobox, AdjaRefLeft,  RegexOptions.IgnoreCase | RegexOptions.Singleline);
						if (mAdjaRefLeft.Success)  NewInfobox = Regex.Replace(NewInfobox, AdjaRefLeft,  @"$1$2",   RegexOptions.IgnoreCase);
						
						Match mAdjaRefRight = Regex.Match(NewInfobox, AdjaRefRight, RegexOptions.IgnoreCase | RegexOptions.Singleline);
						if (mAdjaRefRight.Success) NewInfobox = Regex.Replace(NewInfobox, AdjaRefRight, @"$1$3$4", RegexOptions.IgnoreCase);
					}
					
					// proceed as normal (redo matches first, in case preliminary screening was successful)
					AbsMagJPLRefAnywhere_Pattern = @" *\|\s*" + param + @"\s*= *(.*?)([  ]*\<ref name\s*=\s*[^/\>]*(?:" + JPLRefNameVariants + @")[^/\>]*)"; // 2 groups; preserve leading spaces
					mAbsMagJPLRefAnywhere = Regex.Match(NewInfobox, AbsMagJPLRefAnywhere_Pattern, RegexOptions.IgnoreCase);
					mOldParamFull = Regex.Match(NewInfobox, OldParamFull);
					
					// proceed as normal
					if (!mAbsMagJPLRefAnywhere.Success) // ref(s) exists, but none are JPL; prepare to update/append val and/or jplref to |param=
					{
						// try to find JPL values already referenced in WP param
						Match mFindPPValErr = Regex.Match(mOldParamFull.Value, NewValErr_Pattern, RegexOptions.IgnoreCase); // find the JPL val+error in WP param
						Match mFindWPValErr = Regex.Match("1", "2"); // want false by default; used to find the WP val+error in JPL
						Match mWPValErr = Regex.Match(mOldParamFull.Value, @"(" + PPValues[param].Trim() + @")[\s\+\-±\|]*([\d\.,]*)"); // 2 groups
						if (mWPValErr.Success)
						{
							string WPValErr_Pattern = mWPValErr.Groups[1] + @"[\s\+\-±\|]*" + mWPValErr.Groups[2];
							mFindWPValErr = Regex.Match(NewValErr, WPValErr_Pattern); // find the WP val+error in JPL
						}
						
						if (mFindPPValErr.Success && mFindWPValErr.Success) // non-JPL refs, but identical val+err found, update val+err display & prepend/append jplref (GenFixes fixes order)
						{
							// OldParam is (should be) independent of the existance of <br>'s
							// if inadequate: isolate the entire param line here first, then operate, instead of doing the old param/newparam replacement later
							OldParam = @" *\|\s*" + param + @"\s*= *([^\r\n]*?(?:}}|\>)?[hrdays  ]*)(\{\{\s*(?:val|convert)[^\}]+)?" + NewValErr_Pattern + @"([^\}\{]*\}\})?" + // groups 1-3 this line
										  @"([^\r\n\<\{]*?)((?:\{\{\s*efn|\{\{\s*small)[^\{\}]*\}\})?([  ]*)(\{\{\s*cit[ea][ t]|\{\{\s*small|\{\{\s*efn|\<ref|\<ref(?: name=[^\>]+)?\>\s*\{\{)([^\{\}\<\>]*?)(\}\}\s*\</ref\>|\}\}|\<?/ref\>|/\>)([^\r\n]*(?:[\<\r\n]))"; // groups 4-10
							NewParam = S1234 + @"${1}" + PPValWP[param] + NewErrWP + @"$5$6$7$8$9" + NewRef + @"$10";
						}
						else // non-JPL refs, no identical values; therefore, prepend/append val & jplrefto EoL
						{
							// greedy version of AbsMagRef_Pattern + {{efn}}; propagate &thinsp; ($3); 7 groups
							OldParam = @" *\|\s*" + param    + @"\s*= *([^\r\n]+?)(?:([,  ]*)(\{\{\s*(?:efn|small)[^\}]+\}\}))?([, ]*)( *)((?:\<ref(?!(?: name=[^\>]*|\>) *[\r\n]+)[^\<]*?|\<ref\>\s*\{\{\s*cit[ea][ t][^\<]*?)(?:\</ref\>|/?\>))(" + "[\r\n]+)"; // $3=&thinsp;
							Match mShittyRegex = Regex.Match (NewInfobox, OldParam, RegexOptions.IgnoreCase); // in case the previous OldParam's \n-search fails
							if (!mShittyRegex.Success) // (may no longer be necessary b/c using [\r\n] is more robust)
								OldParam = @" *\|\s*" + param + @"\s*= *([^\r\n]+?)(?:([,  ]*)(\{\{\s*(?:efn|small)[^\}]+\}\}))?([, ]*)( *)((?:\<ref(?!(?: name=[^\>]*|\>) *[\r\n]+)[^\<]*?|\<ref\>\s*\{\{\s*cit[ea][ t][^\<]*?)(?:\</ref\>|/?\>)[^\r\n]*)(" + "[\r\n]+)"; // $3=&thinsp;, also 7 groups
							
							Match mOldParam  = Regex.Match(NewInfobox, OldParam, RegexOptions.IgnoreCase);
							Match mFindBr    = Regex.Match(NewInfobox, @" *\|\s*" + param + @"\s*= *([^\r\n]*?\<br)", RegexOptions.IgnoreCase);
							Match mFindComma = Regex.Match(NewInfobox, @" *\|\s*" + param + @"\s*= *([^\r\n]*?\,(\<ref|\{\{\s*efn|\{\{\s*cite))", RegexOptions.IgnoreCase);
							
							bool shortValueParams = (param == "abs_magnitude") ? true : false;
							if (mFindBr.Success | (!mFindComma.Success && !shortValueParams)) // conform-to or instate <br>-separation, except for short-value params (cleaner IB rendering)
							{
								if ( PrependJPLRefs) NewParam = S1234 + PPValWP[param] + NewErrWP + ThinspRefs + NewRef + @"<br />$1$2$3$4$5$6" + "\n";
								if (!PrependJPLRefs) NewParam = S1234 + @"$1$2$3$4$5$6<br />" + PPValWP[param] + NewErrWP + ThinspRefs + NewRef + "\n";
							}
							else if (mFindComma.Success | (!mFindBr.Success && shortValueParams)) // ","-separate refs
							{
								if (string.IsNullOrEmpty(mOldParam.Groups[3].Value))
								{
									if ( PrependJPLRefs) NewParam = S1234 + PPValWP[param] + NewErrWP + "," + NewRef + @" $1$2$3$4$5$6" + "\n"; // "," instead of ThinspRefs
									if (!PrependJPLRefs) NewParam = S1234 + @"$1,$6 " + PPValWP[param] + NewErrWP + ThinspRefs + NewRef + "\n"; // ThinspRefs instead of ","
								}
								else
								{
									if ( PrependJPLRefs) NewParam = S1234 + PPValWP[param] + NewErrWP + "," + NewRef + @" $1$2$3$4$5$6" + "\n"; // "," instead of ThinspRefs
									if (!PrependJPLRefs) NewParam = S1234 + @"$1,$3$5$6 " + PPValWP[param] + NewErrWP + ThinspRefs + NewRef + "\n"; // ThinspRefs instead of ","
								}
							}
						}
					}
					else if (mAbsMagJPLRefAnywhere.Success) // JPL ref exists! prepare to update val only
					{
						string Spacer = "";
						string AbsMagJPLRefObvious_Pattern = @" *\|\s*" + param + @"\s*= *(.*?)((?<=\b)(?<!\:)\d[\d\.,]*|[\.,]\d+)[^\r\n\<\{\}\>]*?[  ]*(\<ref name\s*=\s*[^/\>]*(?:" + JPLRefNameVariants + @")[^/\>]*)"; // 3 groups; preserve thinsp
						Match mAbsMagJPLRefObvious = Regex.Match(NewInfobox, AbsMagJPLRefObvious_Pattern, RegexOptions.IgnoreCase);
						if (mAbsMagJPLRefObvious.Success) // straight-forward update (finally...)
						{
							if (mAbsMagJPLRefObvious.Groups[1].Value.Length > 0) Spacer = " ";
							OldParam = AbsMagJPLRefObvious_Pattern;
							NewParam = S1234 + @"${1}" + Spacer + PPValWP[param] + NewErrWP + ThinspRefs + @"$3"; // updates val only
						}
						else if (!mAbsMagJPLRefObvious.Success)
						{
							// value might be behind multiple refs
							
							// value might be behind val/convert and/or in front of efn/small (7 groups)
							string Templates_Pattern = @" *\|\s*" + param +
									 @"\s*= *(.*?)(\{\{\s*(?:val|convert)[^\d\r\n]*?)?((?:(?<=\b)(?<!\:)\d[\d\.,]*|[\.,]\d+)(?:\s*[\|\+\-±]+\s*)?[\d\.,]*)([^\}\{\r\n\<]*?)(\}\})?[^\r\n\d\<\{\}\>]*?([  ]*\{\{\s*(?:efn|small)[^\}\r\n]+\}\})?([  ]*\<ref name\s*=\s*[^\>]*(?:" + JPLRefNameVariants + @")[^\>]*\>)"; // 398 Admete was a good test case
							Match mTemplates = Regex.Match(NewInfobox, Templates_Pattern, RegexOptions.IgnoreCase);
							
							// last resort; 4 groups, remove $3; preserve thinsp
							string AbsMagJPLRefBurried_Pattern = @" *\|\s*" + param +
									 @"\s*= *(.*?)((?<=\b)(?<!\:)[\d\.\s\|\+\-±,]+?)([  ]*[^\r\n\d\<\{\}\>]*?)[  ]*(\<ref name\s*=\s*[^/\>]*(?:" + JPLRefNameVariants + @")[^/\>]*)";
							Match mAbsMagJPLRefBurried = Regex.Match(NewInfobox, AbsMagJPLRefBurried_Pattern, RegexOptions.IgnoreCase);
							
							if (mTemplates.Success) // update value surrounded by templates
							{
								OldParam = Templates_Pattern;
								NewParam = S1234 + @"${1}" + PPValWP[param] + NewErrWP + @"$6$7";
							}
							else if (mAbsMagJPLRefBurried.Success) // burried update (multiple refs & values)
							{
								if (mAbsMagJPLRefBurried.Groups[1].Value.Length > 0) Spacer = " ";
								OldParam = AbsMagJPLRefBurried_Pattern;
								NewParam = S1234 + @"${1}" + Spacer + PPValWP[param] + NewErrWP + ThinspRefs + @"$4"; // updates val only
							}
							else Summary += @"*"; // too unusual/very complicated; take chances with the default OldParam & NewParam; use "*" to track these
						}
					}
					
					// perform the update/append
					NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam, RegexOptions.IgnoreCase);
				}
				else if (!mAbsMagRef.Success) // no <ref>s: check for {{efn|cite }}s and <br>s and append val accordingly to either infobox or |param=
				{
					string EfnCiteAnywhere_Pattern = @" *\|\s*" + param + @"\s*= *(.*?)( *\{\{\s*(?:efn|cit[ea][ t])[^\}]+\}\})"; // 2 groups; preserve thinsp
					Match mEfnCiteAnywhere = Regex.Match(NewInfobox, EfnCiteAnywhere_Pattern, RegexOptions.IgnoreCase);
					if (mEfnCiteAnywhere.Success) // no <ref>s, only {{efn|cite }}; prepare to update/append val and/or jplref to |param=
					{
						// try to find JPL values already referenced in WP param
						Match mFindPPValErr = Regex.Match(mOldParamFull.Value, NewValErr_Pattern, RegexOptions.IgnoreCase); // find the JPL val+error in WP param
						Match mFindWPValErr = Regex.Match("1", "2"); // want false by default; used to find the WP val+error in JPL
						Match mWPValErr = Regex.Match(mOldParamFull.Value, @"(" + PPValues[param].Trim() + @")[\s\+\-±\|]*([\d\.,]*)"); // 2 groups
						if (mWPValErr.Success)
						{
							string WPValErr_Pattern = mWPValErr.Groups[1] + @"[\s\+\-±\|]*" + mWPValErr.Groups[2];
							mFindWPValErr = Regex.Match(NewValErr, WPValErr_Pattern); // find the WP val+error in JPL
						}
						
						if (mFindPPValErr.Success && mFindWPValErr.Success) // no <ref>s, only {{efn|cite }}, but identical val+err found, update val+err display & append jplref
						{
							// OldParam is (should be) independent of the existance of <br>'s
							// if inadequate: isolate the entire param line here first, then operate, instead of doing the old param/newparam replacement later
							OldParam = @" *\|\s*" + param + @"\s*= *([^\r\n]*?(?:}}|\>)?[hrdays  ]*)(\{\{\s*(?:val|convert)[^\}]+)?" + NewValErr_Pattern + @"([^\}\{]*\}\})?" + // groups 1-3 this line
										  @"([^\r\n\<\{]*?)((?:\{\{\s*efn|\{\{\s*small)[^\{\}]*\}\})?([  ]*)(\{\{\s*cit[ea][ t]|\{\{\s*small|\{\{\s*efn)([^\r\n\{\}\<\>]*?)(\}\})([^\r\n]*(?:[\<\r\n]))"; // groups 4-10 (ref rem'd)
							NewParam = S1234 + @"${1}" + PPValWP[param] + NewErrWP + @"$5$6$7$8$9$6" + NewRef + @"$10";
						}
						else // no <ref>s, only {{efn|cite }}, no identical values; therefore, append val & jplrefto EoL
						{
							// greedy version of AbsMagRef_Pattern + {{efn|cite }}; propagate &thinsp; ($3); 6 groups
							OldParam = @" *\|\s*" + param + @"\s*= *([^\r\n]*)([, ]*)( *)(\{\{\s*(?:efn|cit[ea][ t])[^\}\r\n]+\}\})()(" + "[\r\n]+" + @")"; // $3=&thinsp;
							Match mShittyRegex = Regex.Match(NewInfobox, OldParam, RegexOptions.IgnoreCase); // in case OldParam fails
							if (!mShittyRegex.Success) OldParam = @" *\|\s*" + param + @"\s*= *([^\r\n]*)([, ]*)( *)(\{\{\s*(?:efn|cit[ea][ t])[^\}\r\n]+\}\})([^\r\n]*)(" + "[\r\n]+" + @")"; // $3=&thinsp;
							
							Match mFindBr = Regex.Match(NewInfobox, @" *\|\s*" + param + @"\s*= *([^\r\n]*\<br)", RegexOptions.IgnoreCase);
							if ( mFindBr.Success) NewParam = S1234 + @"$1$4$5<br />" + PPValWP[param] + NewErrWP + ThinspRefs + NewRef + "\n"; // "<br />"-separate refs
							if (!mFindBr.Success) NewParam = S1234 + @"$1,$4$5 "     + PPValWP[param] + NewErrWP + ThinspRefs + NewRef + "\n"; // ","-separate refs
						}
						
						NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam, RegexOptions.IgnoreCase | RegexOptions.Multiline);
					}
					else if (!mEfnCiteAnywhere.Success) // no <ref>s, no {{efn/cite }}; nothing worth saving (probably); just replace the whole param line
					{
						NewParam = NewParam.TrimEnd();
						Match mParam = Regex.Match(NewInfobox, OldParam);
						if ( mParam.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam); // replace the whole param line
						if (!mParam.Success) NewInfobox = rAppendToInfobox.Replace(NewInfobox, @"$1" + NewParam + "\n" + @"$2"); // append to infobox
					}
				}
			} // end if (mass | abs_mag | rotation | albedo | dimensions)
			else // catch any leftover params in PParameters & add/update IB
			{
				string OldParam = @" *\|\s*" + param + @"\s*=[^\r\n\<]*";
				string NewErrWP = (PPErrWP[param] != "n/a") ? " ± " + PPErrWP[param] : "";
				string NewParam = S1234 + PPValWP[param] + NewErrWP + PPUnitsWP[param];
				NewParam = NewParam.TrimEnd();
				Match mParam = Regex.Match(NewInfobox, OldParam);
				if ( mParam.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
				if (!mParam.Success) NewInfobox = rAppendToInfobox.Replace(NewInfobox, @"$1" + NewParam + "\n" + @"$2");
			}
			
		} // end foreach (string param in PParameters) loop
		
		bool debug4 = false; // 2 Pallas has all of these, for debugging
		if (debug4)
		{
			// see https://en.wikipedia.org/w/index.php?title=User:Tom.Reding/JPL_to_Infobox_planet&oldid=718933095
			// for PParameters, PPValWP, PPUnits, & PPErrWP debugging display
		}
	} // end Physical Parameters Table
	
	
	// Additional Information -> Infobox ////////////////////////////////////////
	
	// isolate the "Additional Information" table & save components
	string AI_Pattern = @"Additional\s+Information.+?\</table\>";
	Match mAI = Regex.Match(JPL_ExternalText, AI_Pattern, RegexOptions.Singleline);
	if (mAI.Success && !Skip)
	{
		string AI = mAI.Value;
		
		string EarthMOID_Pattern = @"\>Earth MOID\</a\> = ([\d\.Ee\+-]+) ([a-z]+)&nbsp;";
		Match mEarthMOID = Regex.Match(AI, EarthMOID_Pattern, RegexOptions.Singleline);
		if (mEarthMOID.Success)
		{
			Param = "moid";
			string EarthMOID = mEarthMOID.Groups[1].Value;
			string EarthMOIDUnits = mEarthMOID.Groups[2].Value;
			if (EarthMOID.Substring(0, 1) == ".") EarthMOID = "0" + EarthMOID;
			if (EarthMOIDUnits == "au") EarthMOIDUnits = "AU";
			else if (skipEntirePageIfAnyJPLUnitsDontMatchExpected)
			{
				Summary += @" AU units expected for " + Param + @"; non-AU units received.";
				Skip = true;
			}
			
			// keep JPL precision since there's no error given for these values
			string OldParam = @" *\|\s*" + Param + @"\s*=[^\r\n\<]*";
			Match mParam = Regex.Match(NewInfobox, OldParam);
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= Param.Length) ? new String(' ', EqualAlignTo - Param.Length) : "";
			
			// use {{Convert}} since apo, peri, semimajor have it (no error values given on JPL for MOIDs)
			string MOIDsuffix = "";
			double dEarthMOID = Convert.ToDouble(EarthMOID);
			if      (dEarthMOID < 0.01)    MOIDsuffix = @"|km|abbr=on}}"; // ~3.9 LD
			else if (dEarthMOID < 6.68459) MOIDsuffix = @"|Gm|abbr=on}}";
			else                           MOIDsuffix = @"|Tm|abbr=on}}";
			string NewParam = S12 + Param + S3 + "=" + S4 + @"{{Convert|" + EarthMOID + "|" + EarthMOIDUnits + MOIDsuffix;
			
			// add to/update infobox
			if ( mParam.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
			if (!mParam.Success) NewInfobox = rAppendToInfobox.Replace(NewInfobox, @"$1" + NewParam + "\n" + @"$2");
		}
		
		string JupiterMOID_Pattern = @"\>Jupiter MOID\</a\> = ([\d\.Ee\+-]+) ([a-z]+)&nbsp;";
		Match mJupiterMOID = Regex.Match(AI, JupiterMOID_Pattern, RegexOptions.Singleline);
		if (mJupiterMOID.Success)
		{
			Param = "jupiter_moid";
			string JupiterMOID = mJupiterMOID.Groups[1].Value;
			string LeadingZero = (JupiterMOID.Substring(0, 1) == ".") ? "0" : "";
			JupiterMOID = LeadingZero + JupiterMOID;
			string JupiterMOIDUnits = mJupiterMOID.Groups[2].Value;
			if (JupiterMOIDUnits == "au") JupiterMOIDUnits = "AU";
			else if (skipEntirePageIfAnyJPLUnitsDontMatchExpected)
			{
				Summary += @" AU units expected for " + Param + @"; non-AU units received.";
				Skip = true;
			}
			
			// use {{Convert}} since apo, peri, semimajor have it (no error values given on JPL for MOIDs)
			string MOIDsuffix = "";
			double dJupiterMOID = Convert.ToDouble(JupiterMOID);
			if      (dJupiterMOID < 0.01)    MOIDsuffix = @"|km|abbr=on}}"; // 0.01 AU = ~3.9 LD
			else if (dJupiterMOID < 6.68459) MOIDsuffix = @"|Gm|abbr=on}}";
			else                             MOIDsuffix = @"|Tm|abbr=on}}";
			
			// add to/update infobox
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= Param.Length) ? new String(' ', EqualAlignTo - Param.Length) : "";
			string OldParam = @" *\|\s*" + Param + @"\s*=[^\r\n\<]*";
			string NewParam = S12 + Param + S3 + "=" + S4 + @"{{Convert|" + JupiterMOID + "|" + JupiterMOIDUnits + MOIDsuffix;
			Match mParam = Regex.Match(NewInfobox, OldParam);
			if ( mParam.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
			if (!mParam.Success) NewInfobox = rAppendToInfobox.Replace(NewInfobox, @"$1" + NewParam + "\n" + @"$2");
		}
		
		string TisserandJup_Pattern = @"\>T_jup\</a\> = ([\d\.Ee\+-]+)&nbsp;";
		Match mTisserandJup = Regex.Match(AI, TisserandJup_Pattern, RegexOptions.Singleline);
		if (mTisserandJup.Success)
		{
			Param = "tisserand";
			string TisserandJup = mTisserandJup.Groups[1].Value;
			string LeadingZero = (TisserandJup.Substring(0, 1) == ".") ? "0" : "";
			TisserandJup = LeadingZero + TisserandJup;
			
			// add to/update infobox
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= Param.Length) ? new String(' ', EqualAlignTo - Param.Length) : "";
			string OldParam = @" *\|\s*" + Param + @"\s*=[^\r\n\<]*";
			string NewParam = S12 + Param + S3 + "=" + S4 + TisserandJup;
			Match mParam = Regex.Match(NewInfobox, OldParam);
			if ( mParam.Success) NewInfobox = Regex.Replace(NewInfobox, OldParam, NewParam);
			if (!mParam.Success) NewInfobox = rAppendToInfobox.Replace(NewInfobox, @"$1" + NewParam + "\n" + @"$2");
		}
	} // end Additional Information
	
	
	// cleanup/finalize /////////////////////////////////////////////////////////
	
	// replace unicode tabs with single space
	NewInfobox = Regex.Replace(NewInfobox, @"	", " ");
	
	// force spacing conformity on several frequently-malformed params that this code otherwise doesn't touch
	List<string> ConformParams = AllParamList; // choose either FrequentlyMalformedParamList (6), UpdatableParamList (~27), AlmostAllParamList (~107), or AllParamList (~113)
	foreach (string param in ConformParams)
	{
		string ConformParam_Pattern   = @"(?<!efn)(?<=[\r\n]) *\| *" + param + @"([ ]*)\=[   ]*";
		string ConformParamNL_Pattern = @"(?<!efn)(?<=[\r\n]) *\| *" + param + @"([ ]*)\=([\r\n]+)";
		Match mConformParam   = Regex.Match(NewInfobox, ConformParam_Pattern, RegexOptions.IgnoreCase);
		Match mConformParamNL = Regex.Match(NewInfobox, ConformParamNL_Pattern, RegexOptions.IgnoreCase);
		
		if (mConformParam.Success)
		{
			string s3 = mConformParam.Groups[1].Value;
			string Spacer = (s3.Length <= 1) ? s3 : "";
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= param.Length) ? new String(' ', EqualAlignTo - param.Length) : Spacer;
			string NewParam = S12 + param + S3 + "=" + S4;
			NewInfobox = Regex.Replace(NewInfobox, ConformParam_Pattern, NewParam);
		}
		else if (mConformParamNL.Success) // have to handle "=\n" differently than "= \n", b/c regex... (or not, if \r\n works)
		{
			string s3 = mConformParamNL.Groups[1].Value;
			string Spacer = (s3.Length <= 1) ? s3 : "";
			if (EqualAlignTo > 0) S3 = (EqualAlignTo >= param.Length) ? new String(' ', EqualAlignTo - param.Length) : Spacer;
			string NewParam = S12 + param + S3 + "=" + S4 + "\n";
			NewInfobox = Regex.Replace(NewInfobox, ConformParamNL_Pattern, NewParam);
		}
	}
	
	// trim end whitespace from parameters, except after "=" (chr32 (keyboard space), chr160 (&nbsp;), &thinsp;)
	string EndWhitespace_Pattern = @"([^\r\n]*?)[   ]+(?<!\=[   ]*)(" + Environment.NewLine + ")";
	Match mEndWhitespace = Regex.Match(NewInfobox, EndWhitespace_Pattern);
	if (mEndWhitespace.Success) NewInfobox = Regex.Replace(NewInfobox, EndWhitespace_Pattern, @"$1$2");
	
	// move lines starting w "<ref" or "</ref" up 1 line

	// done once (preliminarily) near the beginning, and again here, in case any accidental \n's added
	RefLine_Pattern = "[\r\n]+" + @"([  ]*\</?ref)"; // leading space & thinsp
	mRefLine = Regex.Match(NewInfobox, RefLine_Pattern, RegexOptions.IgnoreCase);
	if (mRefLine.Success) NewInfobox = Regex.Replace(NewInfobox, RefLine_Pattern, @"$1", RegexOptions.IgnoreCase);
	
	// remove Infobox lines that don't start with "|", " |", "{{", "}}", or " }}"
	string UnpipedLine_Pattern = @"[\r\n]+(?![   ]*\||\{|[   ]*\})";
	Match mUnpipedLine = Regex.Match(NewInfobox, UnpipedLine_Pattern);
	if (mUnpipedLine.Success) NewInfobox = Regex.Replace(NewInfobox, UnpipedLine_Pattern, "");
	
	// move mean_radius below dimensions (per documentation) since they're closely related
	string Dim_Pattern = @"( *\| *dimensions *=([\=^\r^\n]+))"  + "[\r\n]+";
	string M_R_Pattern = @"( *\| *mean_radius *=([\=^\r^\n]+))" + "[\r\n]+";
	Match mDim = Regex.Match(NewInfobox, Dim_Pattern);
	Match mM_R = Regex.Match(NewInfobox, M_R_Pattern);
	if (mM_R.Success && mDim.Success)
	{
		NewInfobox = Regex.Replace(NewInfobox, M_R_Pattern, ""); // cut mean_radius
		NewInfobox = Regex.Replace(NewInfobox, Dim_Pattern, mDim.Groups[1].Value + "\n" + mM_R.Groups[1].Value + "\n"); // paste mean_radius below dim
	}
	
	// remove <!--(Infobox Comments)--> from non-empty parameters
	List<string> CommentsList = new List<string>(new string[] { // regex
		@"enables features for minor planets", // switches
		@"on top of infobox", // name/designation/image
		@"Minor planet name",
		@"Minor planet category",
		@"Alternative names",
		@"Any alternative names for the body",
		@"displayed in caption of infobox",
		@"image caption",
		@"\<ref\>\.\.\.\</ref\>", // discovery info
		@"Date",
		@"person\(s\), survey",
		@"''discover_site''",
		@"Average orbital speed", // orbital/physical parameters
		@"Instantaneous orbital mean motion",
		@"Angular distance",
		@"Longitude of (the )?ascending node",
		@"Longitude of peri[a-z]*",
		@"Time of peri[a-z]*",
		@"Argument of peri[a-z]*",
		@"Earth MOID only",
		@"Jupiter Tisserand parameter",
		@"Proper orbital mean motion",
		@"Proper perihelic precession rate",
		@"Proper nodal precession rate",
		@"Uni/bi/tri\-axial dimensions",
		@"For planets & large, spheroidal minor planets",
		@"Equatorial surface gravity",
		@"Moment of inertia factor",
		@"Rotational velocity",
		@"Rotation period",
		@"North pole right ascension",
		@"North pole declination",
		@"Pole ecliptic latitude",
		@"Pole ecliptic longitude",
		@"Apparent mag(nitude)?",
		@"Absolute mag(nitude)?",
		@"see ""All parameters"" section" // other
	});
	foreach (string Comment in CommentsList)
	{
		// non-empty = at least 1 non-space, non-"?" character before comment
		string Comment_Pattern = @"( *=[  ]*.{1,})(?<!\=[  ]*\??[  ]*)\<\!\-\-\ *\(? *" + Comment + @" *\)? *\-\-\>"; // thinsp's incl'd
		Match mComment = Regex.Match(NewInfobox, Comment_Pattern, RegexOptions.IgnoreCase);
		if (mComment.Success) NewInfobox = Regex.Replace(NewInfobox, Comment_Pattern, @"$1", RegexOptions.IgnoreCase);
	}
	
	// Infobox-only thinspace standardization (unicode -> &thinsp;)
	NewInfobox = NewInfobox.Replace(" ", @"&thinsp;"); // unicoded &thinsp;s are hard to see & could get lost; convert back to have html
	
	// standardize &thinsp; usage in headings (*_ref parameters)
	if (!string.IsNullOrEmpty(ThinspHeadings) && !Skip) // if &thinsp;'s are used at the start of any *_ref parameter, apply to other *_ref parameters
	{
		List<string> RefParamList = new List<string>(new string[] { "orbit_ref", "p_orbit_ref", "discovery_ref" });
		foreach (string param in RefParamList)
		{
			string NonEmptyParam_Pattern = @" *\|\s*" + param + @"\s*= *(&thinsp;)?([^\r\n]{5,})"; // ">= 5" since "<ref>" = 5 characters long
			Match mNonEmptyParam = Regex.Match(NewInfobox, NonEmptyParam_Pattern, RegexOptions.IgnoreCase);
			if (mNonEmptyParam.Success)
			{
				if (EqualAlignTo > 0) S3 = (EqualAlignTo >= param.Length) ? new String(' ', EqualAlignTo - param.Length) : "";
				string NewParam = S12 + param + S3 + "=" + S4 + @"&thinsp;" + mNonEmptyParam.Groups[2].Value;
				NewInfobox = Regex.Replace(NewInfobox, NonEmptyParam_Pattern, NewParam);
			}
		}
	}
	
	// standardize &thinsp; usage b/w values & refs (only in the positive direction; i.e. don't remove any &thinsp;s)
	if (!string.IsNullOrEmpty(ThinspRefs) && !Skip) // if &thinsp;'s are used > threshold% b/w values and refs, then use 100% of the time
	{
		string ValRef_Pattern = @"(\{\{(?:Convert|Val|Small|Deg2DMS|Deg2HMS|e\|)[^\}]+\}\}|\]\]|\)|\d+|['""a-z])\s*(\<ref|\{\{efn)";
		Match mValRef = Regex.Match(NewInfobox, ValRef_Pattern, RegexOptions.IgnoreCase);
		if (mValRef.Success) NewInfobox = Regex.Replace(NewInfobox, ValRef_Pattern, @"$1&thinsp;$2", RegexOptions.IgnoreCase);
	}
	
	bool debug5 = false;
	if (debug5) Summary += @" ThinspUsageFraction: " + string.Format("{0:N2}", ThinspUsageFraction*100.0) + "%"; // fyi/debug
	
	// remove Infobox lines with only whitespace + pipe
	string EmptyPipes_Pattern = @"(?<=[\r\n]+)([  ]*\|[  ]*[\r\n]+)";
	Match mEmptyPipes = Regex.Match(NewInfobox, EmptyPipes_Pattern, RegexOptions.Multiline);
	if (mEmptyPipes.Success) NewInfobox = Regex.Replace(NewInfobox, EmptyPipes_Pattern, "");
	
	// save infobox changes /////////////////////////////////////////////////////
	ArticleText = ArticleText.Replace(OldInfobox, NewInfobox); //////////////////
	
	// split "-->{{Infobox planet" to separate lines
	string CommentIB_Pattern = @"(\-\-\>[  ]*)(\{\{\s*(?:" + InfoboxAliases_Pattern + "))";
	Match mCommentIB = Regex.Match(ArticleText, CommentIB_Pattern, RegexOptions.IgnoreCase);
	if (mCommentIB.Success) ArticleText = Regex.Replace(ArticleText, CommentIB_Pattern, @"$1" + "\n" + @"$2", RegexOptions.IgnoreCase);
	
	// ArticleText: add/update access-date for RefName_jpl
	JPLRef_Pattern = @"(\<ref name\s*=\s*" + RefName_jpl + @"\s*\>([^\<]+?))\|?(\s*(?:}}|\])?\s*\</ref\>)"; // strict
	mJPLRef = Regex.Match(ArticleText, JPLRef_Pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline);
	if (mJPLRef.Success && !Skip)
	{
		string JPLRef = mJPLRef.Value;
		
		string SkipTemplates_Pattern = @"\{\{\s*(?:MPCit|JPL small body)"; // these don't have/accept an access-date parameter
		Match mSkipTemplates = Regex.Match(JPLRef, SkipTemplates_Pattern, RegexOptions.IgnoreCase);
		if (!mSkipTemplates.Success)
		{
			string AccessDate_Pattern = @"(\|\s*access-?date\s*=\s*)([^\|\}\<]*?)(\s*[\|\}\<])";
			Match mAccessDate = Regex.Match(JPLRef, AccessDate_Pattern);
			if (mAccessDate.Success) // update
			{
				string UpdateAccessDate = @"${1}" + DateTime.Today.ToString("d MMMM yyyy") + @"$3";
				JPLRef = Regex.Replace(JPLRef, AccessDate_Pattern, UpdateAccessDate, RegexOptions.IgnoreCase | RegexOptions.Singleline);
			}
			if (!mAccessDate.Success) // append
			{
				// determine native spacing
				string JPLref = mJPLRef.Groups[2].Value; // JPLref, not JPLRef
				string Spacing_Pattern = @"(\s*)\|(\s*)[a-z-]+(\s*)=(\s*)";
				string s1, s2, s3, s4;
				s1 = s2 = s3 = s4 = "";
				Match mSpacing = Regex.Match(JPLref, Spacing_Pattern);
				if (mSpacing.Success)
				{
					s1 = mSpacing.Groups[1].Value;
					s2 = mSpacing.Groups[2].Value;
					s3 = mSpacing.Groups[3].Value;
					s4 = mSpacing.Groups[4].Value;
				}
				
				string AppendAccessDate = @"$1" + s1 + @"|" + s2 + @"access-date" + s3 + @"=" + s4 + DateTime.Today.ToString("d MMMM yyyy") + @"$3";
				JPLRef = Regex.Replace(JPLRef, JPLRef_Pattern, AppendAccessDate, RegexOptions.IgnoreCase | RegexOptions.Singleline);
			}
			ArticleText = Regex.Replace(ArticleText, JPLRef_Pattern, JPLRef, RegexOptions.IgnoreCase | RegexOptions.Singleline); // save
		}
	}
	
	// remove JPL link from ==External links== as redundant since it is now linked-to in the JPL master ref (2 groups)
	string JPLinEL_Pattern = @"(=+\s*(?:External +links?|References?|Notes?)\s*=+.*?(?!\=\=))([\r\n]+ *[\*\[]+[^\r\n]+?ssd.jpl.nasa.gov/sbdb\.cgi[^\r\n]+)";
	Match mJPLinEL = Regex.Match(ArticleText, JPLinEL_Pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline);
	if (mJPLinEL.Success)
		if (!Regex.Match(mJPLinEL.Groups[2].Value, @"horizons\.cgi", RegexOptions.IgnoreCase).Success)
			if (!Regex.Match(mJPLinEL.Groups[2].Value, "(" + JPLRefNameVariants + ")", RegexOptions.IgnoreCase).Success)
				ArticleText = Regex.Replace(ArticleText, JPLinEL_Pattern, @"$1");
	
	// Correct "[[List of asteroids/1001–2000]]" and other mislink variants
	string Mislink1_Pattern = @"\[\[\s*List of (?:asteroids|minor planets)[/: ]+(\d+001)[ ‐–—-]+(\d+000)\s*\]\]";
	Match mMislink1 = Regex.Match(ArticleText, Mislink1_Pattern, RegexOptions.IgnoreCase);
	if (mMislink1.Success) ArticleText = Regex.Replace(ArticleText, Mislink1_Pattern, @"[[List of minor planets: $1–$2]]", RegexOptions.IgnoreCase);
	
	// Correct "[[List of asteroids/1–1000]]" and variants
	string Mislink2_Pattern = @"\[\[\s*List of (?:asteroids|minor planets)[/: ]+(1)[ ‐–—-]+(1000)\s*\]\]";
	Match mMislink2 = Regex.Match(ArticleText, Mislink2_Pattern, RegexOptions.IgnoreCase);
	if (mMislink2.Success) ArticleText = Regex.Replace(ArticleText, Mislink2_Pattern, @"[[List of minor planets: $1–$2]]", RegexOptions.IgnoreCase);
	
	// dummy-check, just in case
	string DummyCheck =	ArticleTitle_latin + JPL_DDate + Unique_ID + Param + RefName_jpl + JPLDataRef_Master + 
								JPLDataRef_MasterOrSlave + LowellRef_Master + LowellRef_MasterOrSlave + OldInfobox + NewInfobox;
	int IndexOfDummy = DummyCheck.IndexOf("dummy");
	if (IndexOfDummy != -1 && !Skip)
	{
		int start = (IndexOfDummy - 25 < 0) ? 0 : (IndexOfDummy - 25);
		int end   = (IndexOfDummy + 25 > DummyCheck.Length) ? DummyCheck.Length : (IndexOfDummy + 25);
		int width = end - start;
		Summary += "DummyCheck failed, dummy! Excerpt: " + DummyCheck.Substring(start, width);
		Skip = true;
	}
	
	return ArticleText; // end
}