text:
"I Don't Want to Lose What I Called to Say"
The fiction of Stephen Dixon starkly illustrates the difference between realism as a literary effect and "story" as a structural device, a distinction that is often enough blurred in discussions of conventional storytelling. "Realism" is the attempt to convince readers that the characters and events depicted in a given work are "like life" as most of us experience it, but, as Dixon's stories and novels demonstrate, story or plot conceived as the orderly--or even not so orderly--arrangement of incidents and events for explicitly dramatic purposes need not be present for such an attempt to succeed. Few readers are likely to finish his latest novel, Phone Rings (Melville House Publishing) thinking it does not provide a comprehensive and intensely realistic account of its characters and their circumstances, and of the family relationships the novel chronicles, but many if not most will have concluded that fidelity to the stages in Freytag's Triangle has very little to do with its realism.
Which is not to day that Phone Rings has no story to impart, only that it is one that emerges in the narrative long run, through the accumulation of episodes and interchanges (in this case, as in Dixon's previous novel, Old Friends, interchanges over the telephone), although the episodes themselves retain a kind of narrative autonomy separate from their placement as points on a narrative arc. Ultimately, the whole is more than the sum of its parts, but the relationship between the parts is lateral, not linear, the story an aftereffect of Dixon's relentless layering of these episodic elements. (In some Dixon novels, such as, for example, Interstate or Gould, the repetitions, reversals, and transformations he effects through such layering become the story, or at least what makes the story memorable and gives these novels their aesthetically distinctive shape.) One could say that Dixon's commitment to realism precludes imposing "story" when doing so would only be a way of distorting reality by imputing to it more order and more direction than it in fact has.
Dixon's strategy of allowing his fiction to register the mundane and the contingent can seem obsessive, even perverse. In section 7 of Phone Rings, the novel's protagonist, Stu, makes breakfast for his wife. Through a chain of banal actions, Stu accidentally cuts himself with a bread knife. He serves the breakfast and talks with his wife about the fact that he's just cut himself with a bread knife, then, returning to the kitchen and seeing the knife, he wonders what might have happened if the knife had struck his carotid artery. He returns to his wife, who suggests he put a Band-Aid on the cut. The chapter concludes with Stu going back to the kitchen, where he attempts to recreate the situation that led to the accident:
He went back to the kitchen and got the bread knife and opened the refrigerator and wanted to reproduce the way the knife got stuck in the door, but couldn't find a place where it could have got caught. Just somewhere here, in the top shelf of the door, and then before he could do anything about it the knife, buckling under the pressure and something to do with realizing it was stuck and perhaps overcorrecting the situation by pushing the door too far back, sprung out of whatever it was into his neck. Okay, enough; forget about it as you said.
In section 10, "Brother of a neighbor dies. Stu reads about it in the Sun. " Stu wonders whether he should send condolences, starts walking up the hill to the neighbor's house, decides not to after all, and returns home. "I'll just send a condolence card. I'll get it at the drugstore and speak to Peter about his brother sometime after," he says to his wife in the section's closing line.
While these set-pieces are loosely connected to the novel's overarching depiction of Stu's grief over the death of his brother, it certainly cannot be said they advance "plot" in any but the most incremental sort of way--they present us with additional scenes from Stu's life, but do not reduce that life to the bare sum of those scenes. Each provides an equally significant account, however brief or however extended, of Stu's experience (just as the telephone conversations that make up a large portion of the novel's "action" remain self-contained exhanges that allow Stu to invoke past experiences), but Phone Rings, like much of Dixon's fiction, encourages us to consider the portrayal of its characters' experiences as an end-in-itself, not as the prop for a conventional narrative structure artificially imposed on these experiences.
However, if Phone Rings is a novel of character rather than plot, Dixon doesn't always seem at pains to delineate his characters with the expected kind of specificity. Here is a phone exchange between Stu and his brother Dan:
. . ."I'm only calling to tell you something that might interest you that happened today. Of course, also to hear how you are. But that, later, for I don't want to lose what I called to say, unless everything with you's not okay," and Dan said, "No, we're fine. What?" "I was going through my top dresser drawer to throw out all the useless papers and single socks and so on, and came across Dad's old business card," and Dan said "Which one? His dental office or the one he used after he lost his license and sold textiles for what was the company called. . .Lakeside?" and he said "Brookhaven. On Seventh Avenue and 38th." "And a third card. In fact, four," and Stu said "This one was for his 40th Street dental office--his last," and Dan said, "That's what I was getting to. First the Delancey Street offfice, which he had from 1919 till we moved to the West Side in '37, and he set up his practice there. Then Brookhaven, if you're right, and it sounds right--Brookfield or Brookhaven," and he said "Take my word, Haven. . . ..
It is nearly impossible to distinguish between Stu and Dan based on their speech patterns and characteristics alone--and in this novel they are known primarily through their speech. Both exhibit the same tendency to free association and other kinds of roundabout locutions (perhaps influenced by American Jewish speech patterns), to digressive asides and fragmentary utterances. Moreover, many of the other characters in the novel talk like this as well, as if the novel's primary objective is to project a kind of collective voice or to create out of workaday language itself a collective character that is the utlimate focus of Dixon's interest.
This does not mean that the characters in Phone Rings are inadequately rendered or fail to convince as plausibly "real" people. If anything, Dixon's emphasis on the quotidian and the conditional only lends them authenticity--this is the way people actually do talk and act, after all--and his prose style more broadly so insistently restricts itself to the plain narrative essentials, refusing to indulge in figurative embellishments and descriptive decoration (literally sticking to the prosaic) that it might seem these characters are not the creations of writing at all but are merely being caught in the midst of their ongoing, prexisting lives. Thus, chapters begin like this:
His younger daughter comes into the bedroom and says, "Phone call for you." He's working at his work table and says, "Darn, I'm right in the middle of something. That's why I turned the ringer off." "Next time tell us to tell callers you're busy and you'll call back," and he says "Next time I will, thanks," and gets up and picks up the phone receiver and says hello. "Uncle Stu, it's Manny.". . .
This goal of representing life as lived (right down to including details and dialogue most other writers would simply eliminate for efficiency's sake) may also be the motive behind Dixon's often exessively long paragraphs. To adjust his prose to the artificial demands of paragraphing would be a false way of representing the flow of experience, and Dixon's method in effect forces the reader to regard experience in this way--one thing after another. His style--and it is such, a deliberate effort to compose a style that seems without style--does produce a flattening effect, by which actions, thoughts and speech seem to occur on the same discursive plane and receive the same degree of emphasis, but this is more fundamentally the consequence of an approach that seeks to make its treatment of reality as material as possible. We don't get "psychological realism" from Stephen Dixon, at least insofar as that term indicates an effort to plumb the depths of consciousness, to approximate the ineffable. His characters think out loud: "He'd never told Dan this. Thought several times to but then thought better. Made Isaac swear not to tell Dan or Zee about it. 'Oh, on second thought, you can tell her,' after Isaac swore he'd never tell either, 'but not Dan. You do, he won't let me take you anywhere for the next few years. I know him. . . .'"
What originates in Stu's ruminations becomes just another form of exposition.
I find Dixon's strategies fascinating (he ususally manages to extend them just a little bit farther with each book) and his ability to elicit from them compelling and often emotionally affecting fictions impressive indeed. He's one of the few writers to whose work the descriptions "experimental" and "realistic" seem to apply equally, although his inclination to the former is almost always a way of further securing the latter. His relative lack of popularity among even readers of serious literary fiction is both surprising and understandable: Surprising because he's finally such an engrossing and rewarding writer, understandable because his style of realism, shunning as it does the facile resort to "story," calls into question the idea that fiction functions to elucidate life by, figuratively at least, whipping it into shape.
January 31, 2006 in Realism in Fiction | Permalink | Comments (3) | TrackBack (1)
Cavalier Assertions
Michiko Kakutani in the New York Times, January 17:
Mr. Frey's embellishments of the truth, his cavalier assertion that the "writer of a memoir is retailing a subjective story," his casual attitude about how people remember the past - all stand in shocking contrast to the apprehension of memory as a sacred act that is embodied in Oprah Winfrey's new selection for her book club, announced yesterday: "Night," Elie Wiesel's devastating 1960 account of his experiences in Auschwitz and Buchenwald.
New York Times, January 19:
The publisher and the translator of a new English-language edition of "Night," Elie Wiesel's harrowing account of life in the Nazi death camps, said yesterday that the new edition corrects several small factual errors in the previous translation, including a reference to the author's age when he entered the camps.
Oprah Winfrey's choice of "Night" as the next selection for her television book club on Monday immediately sent the book to the top of national best-seller lists.
But it also revived questions about "Night," one of the first autobiographical accounts of the death camps and a book that changed modern American understanding of the Holocaust. At times over the last 45 years it has been classified as a novel on some high-school reading lists, in some libraries and in bookstores.
Some scholars who have studied Holocaust memoirs have also raised questions about how much of the book can be verified.
Mr. Wiesel and his literary agent, Georges Borchardt, said in interviews this week that the book was factual and that they had never portrayed it as a novel. They said the differences in the new edition are not significant enough to justify the kind of questions raised about Ms. Winfrey's last book club selection, the memoir "A Million Little Pieces" by James Frey
Just a suggestion: "Nonfiction narrative" is inherently a genre in which facts are going to be shaded and embellished in the name of story. In demanding that our "nonfiction" also be "narrative," let's not pretend that it is as well providing us with "the truth." Frey's embellishments may or may not have been warranted, but if we stopped fetishizing "story" as embodying some kind of transcendent value, he may not have resorted to them in the first place.
January 19, 2006 in Narrative Nonfiction | Permalink | Comments (0)
Chris Bachelder makes as good a case for Upton Sinclair's The Jungle as I've read in a while:
The Jungle aims to provide an accurate report of the many ways that life in Packingtown crushes people, destroys their power of self-determination, even their humanness. Individual desire, typically the engine of fiction, is eradicated. If Sinclair's characters seem to lack agency or a certain kind of Rooseveltian pluck, if they seem unresponsive or passionless, well, that's the point. Readers may long for a tender conversation between Jurgis and Ona as they hold each other on a particularly cold night, but as Sinclair writes, "truly it was hard, in such a life, to keep any sentiment alive."
Later in his career, Sinclair knew himself well enough as an artist to tell the critic Van Wyck Brooks that "some novelists I know collect their material with a microscope, and I collect mine with a telescope." E.L. Doctorow once said that contemporary American writers are more technically proficient and far less socially or politically motivated than previous generations of writers (many of whom began as journalists). Readers of contemporary literary fiction have grown accustomed to the novel's microscopic power to render, often beautifully, the small moments of a character's life. Conversely, we've grown skeptical of the novel's telescopic function to bring large, distant abstractions into focus. We're wary of the big picture. And if the accurate depiction or explanation of the world outside our minds is not a part of our conception of Good Literature, we will fail to recognize the power of The Jungle.
The problem with this, however, is that an "accurate depiction" is not the same thing as an "explanation." A realist writer (Flaubert or James, for example) may indeed render an accurate depiction, either of the world inside or outside our minds, without presuming to offer an explanation--an ideological or conceptual grid onto which we are to project the depicted world. More often than not, through the focus on the concrete rather than the abstract, such writers ultimately convey more of the complexity of human experience than its capacity to be reduced to simple explanations. In effect, the more we know, the less we know. (In this sense, the epistemic skepticism Bachelder speaks of in his essay is a consequence of the novel's own "artful" techniques of exploring experience rather than the "sustained attacks on objectivity and truth" by contemporary philosophers.)
Sinclair pretty obviously did want to provide an "explanation." He wanted not merely to portray "the many ways that life in Packingtown crushes people," but to bring the reader, along with The Jungle's protagonist, to an appreciation of socialism as an alternative to the unrestrained capitalism the novel exposes. And, as Baldechar pouts out, Sinclair himself admitted he had failed at this goal: "I aimed at the public's heart, and by accident I hit it in the stomach." Still, sickening readers through the power of description is not an insignificant accomplishment. It does show that whatever skills as a writer Sinclair did possess finally overshadowed his more dubious talents as a political theorist.
Although one can acknowledge the "power" of The Jungle and still wonder why it needed to be written as a novel at all (beyond the usual bromides about the way novels offer "identification" and "intimacy"). The accuracy of its depictions could have been achieved just as readily in nonfiction as fiction, their truthfulness perhaps becoming only more consequential as a result. Is "accuracy of depiction" even something that distinguishes fiction as a literary form in the first place?
Born of Blood and Emotion
When I wrote this post, I did not know that Poetry editor Christian Wiman participated in the 2004 conference, "Celebrating Wallace Stevens: The Poet of Poets in Connecticut," at the University of Connecticut. According to this account at electronic book review, here is what Wiman had to say:
. . .Throughout the entire proceedings, he had sat a bit pushed back from the table, looking sallow and brooding, else intent and reticent. When his turn came to speak, he cleared his throat and slowly, in carefully enunciated syllables, began with this proposition: if Wallace Stevens is influential in 50 years, then the break between American poetry and the world will be complete. Much of the crowd, a bit confused by this comment, leaned in attentively. Was Stevens a great poet? Yes of course. But, was he a companionable poet? No, not at all. In fact - Wiman continued in measured tones - he was almost inhuman, uprooted, impenetrable, unpenetrating, a self-indulgent effete, a hyper-cerebral poet with raw talent blazing but little sense of how to convey something a reader might enter into, something born of blood and emotion and the shared commonalities of lived life. He was a destructive influence on modern poetry. . .Stevens' poetry has abjured the world, Wiman continued, he lived in a bubble of the mind so that he might not be infected by life. His poetry corrosively and obsessively studied itself and was utterly unconcerned with the specificity of things and with relationships to people. There was coldness or distance that Wiman sensed in Stevens' poetry and it turned him off, way off, didn't arrive at the root of him as a reader. The early poems thought in sounds, not in ideas, and throughout Stevens' career, all he could see were busy associative surfaces with very little depth. . . .
What strikes me most about this passage (acknowledging that it is a paraphrase of Wiman's remarks, not direct quotation), is the dishonesty of allowing that Stevens might be a "great poet," even though his poems have the grave defects Wiman enumerates. Clearly Wiman doesn't believe Stevens is a great poet; how could someone who had "a destructive influence on modern poetry" be great? Wiman has high moral standards for poetry to meet--it mustn't be "inhuman" (that word again),"uprooted," "self-indulgent"--and manifestly Stevens's poetry doesn't measure up. (Although is is important to note that these standards are moral. There's nothing in this diatribe that actually touches on Stevens's facility as a poet, his ability to indeed think "in sounds.")
Although perhaps it is more important for a poet to be "companionable" than to dilly-dally around so much with words and stuff, more important to offer "something born of blood and emotion" (as if Stevens's poems don't contain emotion--has Wiman read "The Death of a Soldier"?) than to write skillful and provocative poems. Presumably Poetry will be publishing poems that manifest the opposite qualities Wiman describes here, and readers can decide for themselves whether they represent an advance in the art of poetry. But if I had to bet on what will be influential 50 years from now, the issues of Poetry editied by Christian Wiman or the poems of Wallace Stevens, my money is decidedly on the latter.
Thanks to John Palatella for alerting me to the ebr article.
January 13, 2006 in Poetry | Permalink | Comments (4)
Market Discipline
Rather than use its $175 million to help out actually existing poets directly, the Poetry Foundation is instead going to engage in some social work: ". . .the stewards of that large sum believe they can use it to bring poetry 'back into the mainstream of American culture'". This involves "a series of programs designed to jumpstart interest in poetry among nonspecialist readers."
Bizarrely, the goal of these "programs" is intended to build "a readership for poetry large enough to make it possible for more poets to succeed in a commercial marketplace rather than rely on academia to make a living." Why such a roundabout way of giving poets some assistance, unless the real goal is to further debase American poetry by forcing it to be "commerical"? (''More poems should rhyme," says Poetry editor Christian Wiman. "More poems should have meter. More poems should tell stories in accomplished ways. More poems should do the things that people like poems to do.") Unless the real recipient of the foundation's beneficence is capitalism itself, which will now teach even poets a good lesson in the imperatives of market discipline?
We are told that "the foundation's strategy emphasizes rebuilding a general, nonspecialist, and, crucially, nonacademic audience for poetry." The assumption everyone involved in this project seems to share is that at one time poetry did have a "broader readership" that contemporary poets for some reason renounced and that the self-appointed saviors of the Poetry Foundation will now reclaim. But when was this "golden age" that Wiman in particular speaks of? Certainly not in my lifetime. The greatest American poets of the twentieth century are, arguably, Wallace Stevens and T.S. Eliot, both of whom published in Poetry. How much influence did they have on "the mainstream of American culture"? They profoundly influenced those who take literature seriously, but what impact did their work have on "general, nonspecialist" readers? Even now, what would such readers make of "The Idea of Order at Key West" or "Four Quartets"? They would be as incomprehensible to them as the most elusive lines of John Ashbery or the most resolutely nonreferential L=A=N=G=U=A=G=E poems.
What is a "specialist" reader? Someone who reads poetry? What's a "nonspecialist" reader? Someone who can take it or leave it? Why would poets want to appeal to such a reader?
James Longenbach has it right. People like Christian Wiman and John Barr and Dana Gioia are invested in the notion that poetry is "good for us." It's this "good" they're interested in spreading around along with their money, not poetry itself. Longenbach says further: ''Poets can do without much money. . .and that's a good thing. . . . Poets have much more aesthetic freedom precisely because nobody cares how or what they write. That freedom is priceless." I agree. And American fiction might benefit if more fiction writers took this idea seriously as well.
January 11, 2006 in Poetry | Permalink | Comments (17)
A Measure Beyond Art
In an essay in the December issue of The New Criterion (unfortunately no longer available at the website except through the purchase of a "token"), Roger Kimball offers a laudatory account of Art in Crisis, written by the Austrian art historian (and Nazi party member) Hans Sedlmayr. "Autonomous man," according to Sedlymayer, "does not and cannot exist—any more than can autonomous art, architecture, painting and so on. It is of the essence of man that he should be both natural and supernatural … . Man is fully human only in so far as he is a repository of the divine spirit."
Kimball shares Sedlymayer's contempt for the notion that art might have autonomous value:
One need not, I think, share Sedlmayr's theological convictions in order to appreciate the power of his strictures about the search for autonomy. "The fact is," he argues, "that art cannot be assessed by a measure that is purely artistic and nothing else. Indeed, such a purely artistic measure, which ignored the human element, the element which alone gives art its justification, would actually not be an artistic measure at all. It would merely be an aesthetic, and actually the application of purely aesthetic standards is one of the peculiarly inhuman features of the age, for it proclaims by implication the autonomy of the work of art, an autonomy that has no regard to men—the principle of l'art pour l'art." Art has its own aesthetic canons of legitimacy and achievement; but those canons are themselves nugatory unless grounded in a measure beyond art. That is the ultimate, indispensable, lesson of Art in Crisis.
One hears this sort of thing all the time, and not just from conservatives such as Kimball. Art that is "purely artistic" (itself such a logically dissonant notion--what proportion of art should be something other than artistic? 5%? 50%?--as to make all accounts of art proceeding from this assumption inherently absurd) lacks the "human element," privileges the autonomy of art over "regard to men." Art needs to accomodate itself (or be made to accomodate) some larger, more important conceptual order: if not religion, then politics, history, ethics, or "culture" regarded as a kind of substitute for "theological convictions."
But, since art is made by human beings for the consideration of other human beings, I just find it puzzling what it means to say that some art might be "inhuman." Is the "human element" in art something mystical to be intuited from the work, or is it stirred in like the secret ingredient in the spaghetti sauce? (Of course, in the case of the Nazi Sedylmayer, we can make a pretty good guess about who and what is being identified in his use of the word "inhuman.") What, finally, can be more "human" than to exercise the imagination in such a thoroughgoing and transformative way as to create a poem, painting, or musical composition that seems so self-sufficient that we want call it "autonomous"? What's inhuman about admiring such an effort to the extent of creating a vocabulary to describe its effects? In my opinion, people who opine about the "merely aesthetic," who find aesthetic values "nugatory" unless they are subservient to a higher principle of judgment, manifestly disdain art except as an illustrative aid, a utilitarian convenience.
It has always been relatively clear (at least to me) that Roger Kimball's protestations against the coarsening of art and the study of art have always been hollow, at best a rhetorical expedient in the broader struggle against liberalism, in the "arts" branch of which Kimball has been one of the most prominent combatants. But it is additionally illuminating to find him admitting that aesthetics mean little to him. (Although it is a little surprising that he would explicitly cite the anti-modernist ravings of a fascist art historian to support his position.) The view of art Kimball expresses here is in many ways representative of the long-standing conservative belief that art should serve simply as one of the props of culture (as it also explains the reflexive horror with which many conservative commenators recoil from unconventional or transgressive art), but the essay should also be a useful reminder the next time Kimball--or one of his like-minded colleagues--rails against the latest outrage among artists or literary critics that artistic accomplishment is really the least of his concerns.
January 07, 2006 in Art and Culture | Permalink | Comments (12) | TrackBack (0)
Booksquare takes some exception to the notion that, according to The Sunday Times, "the [book] industry has become incapable of spotting genuine literary talent.":
While our first tendency is to draw comfort from having our worst suspicions confirmed, there is a stronger tendency to explore the idea that while Naipaul and Middleton are fine authors, they do not appeal to every reader. Thus, when it comes to make business decisions (and one must recall that representing or publishing books is indeed a business decision), different criteria are used to judge work. . . .
But this is, of course, the very point of Times article. It does not claim that "the book industry has become incapable of making business decisions" (although one could certainly question the wisdom of many it does make). Obviously, the implication of this experiment (submitting chapters from books by V. S. Naipaul and Stanley Middleton to various publishers, only to have them rejected) is that the overriding imperative in contemporary publishing is to indeed apply "different criteria" than literary merit. Perhaps Naipaul and Middleton "do not appeal to every reader," but that their work manifests "literary talent" seems to me undeniable. The "book industry" and its apologists need to make up their minds: Either "literary talent" no longer matters and publishing any piece of dreck that comes along on the suspicion it might make money is now acceptable practice, or it does matter and the publishing world is doing a dreadful job of serving that talent.
January 04, 2006 in Writing and Publishing | Permalink | Comments (10)


text:
Women's softball struggles offensively in first tournament of the season
Katherine Harris, Senior Writer
The softball team came back strong on its second day of competition during a Feb. 8-9 road trip but were unable to overcome some tough competition, finishing the Cleveland State Dome Tournament with a 1-3 record.
"We are definitely looking to score one or two more runs per game, but coming out of the first weekend only losing by one run is never a bad place to start. This weekend was only a small glimpse of how great I think our offense can be," Amanda Fazio '16 said.
The Bison started off their weekend with a match against the home team Cleveland State. Fazio took the mound for the team in the defensive battle, recording six strikeouts while allowing only six hits and only one unearned run in her first start of the season. However, her teammates struggled to convert on the offensive end. Courtney Conover '14 had a double, and both Erin Cox '15 and Cydnee Sanders '15 had singles, but it was not enough for the Orange and Blue in the 1-0 loss.
The Bison turned on their offense in the second match of the day but couldn't overcome Canisius in the 11-10 loss. Jacee Almond '17 and Kristen Zahn '15 led the offensive explosion, each contributing two-run homers along with the rest of their offensive production. The defense was not able to hold out against a strong opponent, even though reliever Lara Bean '17 pitched over six innings with just three hits and one run earned.
"I was overall very happy with how I played. I am coming back from an injury that ended my season last year so it was a great feeling being back on the field," Zahn said.
The Orange and Blue came into their second day of competition swinging, ready to take on Bowling Green in the morning. Bean contributed to the shutout with a start on the mound for the team, earning her first career win, while Dana Nielson '16 earned a save by pitching two innings with three strikeouts and only one hit. Many Bison contributed on offense, with Sanders and Zahn leading the way with doubles in the sixth to seal the deal with the second run in the 2-0 victory.
The Bison were unable to finish out the day with a win when they dropped their final game of the tournament to Robert Morris 4-3. Almond and Zahn both continued their strong weekends with homers, while Fazio and Nielsen both contributed strong performances on the mound. The team was unable to tie up the contest and ended the weekend on a disappointing note.
"What held us back in a few of the games was a slow start to our offense but eventually we were able to make the adjustment–it was just a little late in a few of the games," Zahn said.
The Bison will compete in the Longwood Spring Classic starting tomorrow in Farmville, Va.

redpajama_set_name: RedPajamaCommonCrawl


text:
Adam Alojzy Chołoniewski (zm. w 1772) – podstarości winnicki, podstoli winnicki (1736), chorąży dźwinogrodzki (zwinogrodzki, 1750), sędzia grodzki bełski (1753), podkomorzy bełski (1758), starosta dubieński, kasztelan buski (1766), senator I RP (1766). Żona – Salomea z Kąckich h. Brochwicz.

Poseł na sejm 1766 roku z województwa bełskiego.

Zobacz też
 Chołoniewski Hrabia

Przypisy

Bibliografia

Adam Chołoniewski
Chorążowie zwinogrodzcy
Kasztelanowie buscy
Podkomorzowie bełscy
Podstarościowie (województwo bracławskie)
Podstolowie winniccy
Posłowie na sejm zwyczajny 1766
Posłowie na Sejm I Rzeczypospolitej (województwo bełskie)
Sędziowie grodzcy bełscy
Starostowie dubieńscy
Zmarli w 1772

redpajama_set_name: RedPajamaWikipedia


text:
Guilherme Pessoa-Amorim
guilherme.pessoa-amorim@ndph.ox.ac.uk
guilherme.pessoa-amorim@seh.ox.ac.uk
Clinical Trial Service Unit and Epidemiological Studies Unit (CTSU)
Clinical Research Fellow
I am a DPhil student at the Clinical Trial Service Unit and Epidemiological Studies Unit (CTSU). My DPhil project is funded by the Medical Research Council and will determine the feasibility of using routinely collected data on drugs dispensed to patients as a primary source of information about medications for participants in large-scale randomised controlled trials.
Recently, NHS Digital has released a new dataset on medicines dispensed in the community in England. This dataset represents an extraordinary opportunity to bring the worlds of clinical care and clinical research closer together. Nonetheless, it is first crucial to explore this dataset in detail, namely how it is produced, its technical features, and its coverage. Then, it is important to understand how these data compare to other similar sources of data on medications, and finally whether it is feasible to incorporate it in medical research, and in clinical trials in particular.
I began my academic career in 2019 when I joined CTSU to work in the AMALFI trial, a study which aims to shed light on the burden of subclinical atrial fibrillation in elderly high-risk patients. I am also part of the clinical team for the ORION-4 trial, a study which is assessing the effect of inclisiran, a novel cholesterol-lowering therapy, on cardiovascular events on patients with established atherosclerotic disease. More recently, I joined the RECOVERY trial, the largest randomised controlled trial of new treatments for patients hospitalised with COVID-19.
Admission of patients with STEMI since the outbreak of the COVID-19 pandemic: a survey by the European Society of Cardiology.
Pessoa-Amorim G. et al, (2020), Eur Heart J Qual Care Clin Outcomes, 6, 210 - 216
Impaired Left Atrial Strain as a Predictor of New-onset Atrial Fibrillation After Aortic Valve Replacement Independently of Left Atrial Size
Pessoa-Amorim G. et al, (2018), Revista Espanola de Cardiologia, 71, 466 - 476


text:
Tetramorium spinosum är en myrart som först beskrevs av Theodore Pergande 1896.  Tetramorium spinosum ingår i släktet Tetramorium och familjen myror. Inga underarter finns listade i Catalogue of Life.

Bildgalleri

Källor

Externa länkar

Myror
spinosum


text:
The 2004 World Outdoor Bowls Championship men's pairs was held at the Northfield Bowls Complex in Ayr, Scotland, from 23 July to 7 August 2004.

Keith Roney and Ryan Bester of Canada won the gold medal.

Qualifying round
Four sections, three teams from each section qualify for Championship round.

Section 1

Section 2

Section 3

Section 4

Championship round

Section 1

Section 2

Bronze medal match
Wales beat New Zealand 15–9.

Gold medal match
Canada beat Ireland 19–15.

Results

References

Men


When one vertebra slips forward onto the bone below, it is usually defined as spondylolisthesis. This condition most frequently occurs in the lumbar (lower back) region, but can happen anywhere within the spine. This causes intense pressure on the spinal cord and surrounding nerves, in turn creating pain and discomfort that will likely become severe if left untreated. Treatment will be recommended on an individual basis, with factors such as the severity of the complex spinal deformity and the patient's surgical and health history all carefully considered.
During this type of procedure, Mr Furtado will use screws, rods and bone graft to carefully fuse problematic vertebrae together and correct deformities in the spine. Advanced spinal fusion techniques are often used when treating scoliosis, kyphosis, spondylolisthesis and other conditions.
For more information on spinal deformities please do not hesitate to get in touch with Mr Furtado through our appointments page.


3. The British drink about 165 million cups of tea a day.
4. Britain is the second-largest nation of tea drinkers per capital Ireland is the first.
5. China is the world's largest producer of tea. In 2009, China produced 1,359,000 tonnes; India was second with 979,000 tonnes.
6. An estimated 85% of tea that is consumed in the United States is iced tea.
7. Over 519 million pounds of tea are imported into the United States each year.
8. After water, tea is the most widely consumed beverage in the world.
9. It takes around 4 to 12 years for a tea plant to produce a seed. It takes about three years before a new plant is ready to harvest.
10. Tea plants need at least 50 inches of rain a year.


Along with Medical Coding, AE & Associates offers solutions for your medical billing needs. Led by our Medical Billing Manager, Michelle Bagaygay, our team of experienced billers will make sure your billing is handled with the upmost skill and professionalism our company can offer. We can effectively maximize revenue for our clients, while being very proficient in our billing process. Let us be the ones that will give you a financial boost by using our billing service.
Claims are submitted electronically within 24 hours of receipt. Almost all unquestioned claims are paid within 30 days, and in some cases even earlier.
Or we will process paper claims for those payers who do not have the capability of processing claims electronically.
Monthly statements are mailed out for each account with a deductible or patient responsibility balance.
We will consistently and proactively review, correct and resubmit any unpaid claims, denials and outstanding patient balances.
Offers you a complete and powerful perspective on the business side of your medical practice. It gives you the information and insight to make important decisions to increase your bottom line.
Implementing efficient processes to handle and manage reimbursements are vital to ensuring all the revenue generated in your office is captured.
Assess current coding and billing protocols identifying opportunities to increase revenue and profitability.
Knowing which services payers actual pay for, how much they pay and when they pay is essential for sound practice planning. Our payer analysis gives you this information and more.
Identify significant denial patterns and payer payment variances.
Reports will summarize the total dollar amount of denied claims along with the reason for denial.
Detailed information of each denial and potential reimbursement issues.
Credentialing requirements and guidelines are ever changing. They are time and labor intensive. We provide credentialing and credentialing maintenance for both new and established providers.
Snapshot report summarizing your monthly collections, accounts receivables, and denials.
At the end of every month we will provide you with a Feedback and Recommendations report for your internal office to use to make changes regarding patient files (ie updating insurance information), and internal office processes (ie change in codes).
AE can train Physician staff in identifying and verifying Pts for proper Eligibility screening and Registration to guarantee maximum probability of payment for services rendered.
AE can train Providers in regards to proper coding to optimize revenue based on their contracts with Payers.
Our team provides a variety of consulting services.
Review contracts for clauses, accuracy and expiration.


text:
Israel/ Palestine
Seven members of Israeli 'terror cell' indicted for dozens of attacks on Palestinian civilians & property
By Celine Hagbard | (IMEMC) | – –
On Monday, an Israeli court indicted seven Israelis, including two sons of a leading rabbi, a soldier, and two minor teens, for participating in dozens of attacks against Palestinian civilians in the Hebron area, in the southern part of the West Bank.
The Israeli court prosecutor asked that three of the suspects be held in prison, with the others held under house arrest. The men and boys involved in the 'terror cell' have confessed to numerous attacks, some dating back as far as 2008.
A group of six youths, three of whom are the sons of the head Rabbi in an illegal Israeli settlement, have admitted to a series of attacks against Palestinians dating from 2008 to the present.
The Israeli security service Shin Bet announced Wednesday that the six youth are being investigated for a number of attacks, but have not yet been charged with any crimes, despite their admissions of guilt.
No 'harsh interrogation' tactics or physical coercion were used against the six young men, according to the Shin Bet. Palestinian detainees of the same age range are subjected to torture and abuse in up to 90% of the cases, according to the Palestinian Prisoner Society.
The suspects have been identified as Pinchas Sandorfi, 22, Itamar Ben Aharon, 20, Michael Kaplan, 20, two boys aged 16 and 17, and an unnamed Israeli soldier. All of the suspects are from an Israeli settlement colony in the Binyamin bloc.
Lawyers for the six suspects complained to Israeli authorities that they had been prevented from meeting with their clients prior to their interrogations by Israeli authorities. One of the lawyers also complained that because most of their crimes did not end up hurting anyone, they should not face charges.
The Israeli terror cell has allegedly been carrying out attacks for years – these attacks included the beating attack of a Palestinian in July 2015, and an attack on a Palestinian home in December 2015 in which the perpetrators threw tear gas canisters into a home in which a family was sleeping.
The family, including a nine month old baby who was asleep in the home, were able to escape without injury.
The other attacks admitted by the group include firebombing vehicles and homes, writing graffiti and hate speech on Palestinian businesses and homes, and attempting to burn a Palestinian family alive (unsuccessfully) in Mazra'a al-Qibliya village this past November.
No charges have yet been levied against the men and teens involved in these attacks. Police say the suspects are still under investigation.
Via IMEMC
New China TV: "Jewish extremist convicted for killing palestinian teen"
Filed Under: Israel/ Palestine


We used both lemons and limes to make this chilled berry-spiked drink.
In a 2-1/2-quart pitcher, combine lemon juice, lime juice and 3/4 to 1 cup honey. Add water and raspberries. Cover and chill for at least 4 hours or up to 24 hours.
Just before serving, gently stir to combine. Pour into ice-filled glasses. If you like, add lemon and/or lime slices. Sweeten to taste with additional honey or sugar, if you like. Makes 8 to 10 (6- to 8-ounce) servings.
Lemonade Tea: Add equal parts freshly-brewed iced tea and Tangy Citrus Lemonade to ice-filled glasses. Sweeten to taste with additional honey or sugar.


I've always loved eating at Golden Cowrie Filipino Restaurant and Hukad sa Golden Cowrie ever since their branched opened at our home town, Dumaguete. So when I visited Cebu last summer, it was one of the places my Manileño and Cebuano friends tried due to their popular traditional Filipino dishes.
Their restaurant offers enjoyable and nourishing dining experience embodying the Filipino cuisine at an affordable price range. The place has an ambiance of traditional houses – wooden and classy – that connotes the feeling of togetherness shared when dining with family and friends. They have friendly and approachable staff that caters your needs to entice your dining experience.
Most importantly, their food is the main reason why people always love to come back. They have a distinct flavors and taste that is perfectly suited to the Filipino's appetite.
Such homegrown Cebuano brand has established itself due to its authentic taste and quality, and has grown across the Visayas and Mindanao region.
Golden Cowrie Filipino Restaurant and Hukad sa Golden Cowrie overall offers a modern dining experience that is reminiscent of Filipino celebrations where family and friends come together to share festive moments.
Golden Cowrie –Lahug is located at Salinas Drive, Lahug, Cebu City. You may reach them through their telephone numbers: (032) 233-4243 / 233-4670. It also opens daily from 11:00 am to 2:00 pm and 5:00 pm to 10:00 pm.
For further inquiries, visit their website: alwaysafeast.ph and facebook. You may also tag them through these hashtags: #AlwaysAFeast and #HukadGoldenCowrie.


La Murada is in the Alicante province but sits on the Murcia border, the ideal spot to explore both regions and the Costa Blanca.
Airports; Alicante. Just 35 minutes drive (50km). Cavera Murcia. 55 minutes.
La Murada is famous for its Sunday market, which stretches through many streets with a vast array of different things to buy. All the bars and restaurants are open which makes for a special Spanish day out.
The Olive Mill is set in the countryside, but don't worry Google Maps will bring you straight to our door.
Car hire is recommended, we advise www.laracars.com. No hidden costs or hassle. When booking at The Olive Mill, please ask us for our discount code.
We can offer you airport transfers from Alicante Airport.
An ideal location for cycling, walking and bird watching. Beautiful countryside, mountain views and expanses of lemon & orange groves. Being on the border means it is easy to explore both regions and we boast 330 days of sunshine each year.
At The Olive Mill we offer just what you are looking for, the perfect holiday.
Call us on 0034 966 180 894 or email here.


The fully revised new edition of Tourism Concern's acclaimed Ethical Travel Guide has now been published. It gives a background to the many ethical and practical issues involved in ethical tourism, including a new section on travel and climate change.
The book was written by Polly Pattullo and Orely Minelli and published by Earthscan.


text:
// <copyright file="Size5D.cs" company="Shkyrockett" >
//     Copyright © 2005 - 2020 Shkyrockett. All rights reserved.
// </copyright>
// <author id="shkyrockett">Shkyrockett</author>
// <license>
//     Licensed under the MIT License. See LICENSE file in the project root for full license information.
// </license>
// <date></date>
// <summary></summary>
// <remarks></remarks>

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Xml.Serialization;

namespace Engine
{
    /// <summary>
    /// The size5D struct.
    /// </summary>
    /// <seealso cref="IVector{T}" />
    [DataContract, Serializable]
    [TypeConverter(typeof(Size5DConverter))]
    [DebuggerDisplay("{" + nameof(GetDebuggerDisplay) + "(),nq}")]
    public struct Size5D
        : IVector<Size5D>
    {
        #region Implementations
        /// <summary>
        /// Represents a <see cref="Size5D" /> that has <see cref="Width" />, <see cref="Height" />, <see cref="Depth" />, <see cref="Breadth" />, and <see cref="Length" /> values set to zero.
        /// </summary>
        public static readonly Size5D Empty = new Size5D(0d, 0d, 0d, 0d, 0d);

        /// <summary>
        /// Represents a <see cref="Size5D" /> that has <see cref="Width" />, <see cref="Height" />, <see cref="Depth" />, <see cref="Breadth" />, and <see cref="Length" /> values set to 1.
        /// </summary>
        public static readonly Size5D Unit = new Size5D(1d, 1d, 1d, 1d, 1d);

        /// <summary>
        /// Represents a <see cref="Size5D" /> that has <see cref="Width" />, <see cref="Height" />, <see cref="Depth" />, <see cref="Breadth" />, and <see cref="Length" /> values set to NaN.
        /// </summary>
        public static readonly Size5D NaN = new Size5D(double.NaN, double.NaN, double.NaN, double.NaN, double.NaN);
        #endregion Implementations

        #region Constructors
        /// <summary>
        /// Initializes a new instance of the <see cref="Size5D" /> class.
        /// </summary>
        /// <param name="size">The size.</param>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Size5D(Size5D size)
            : this(size.Width, size.Height, size.Depth, size.Breadth, size.Length)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="Size5D" /> class.
        /// </summary>
        /// <param name="point">The point.</param>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Size5D(Point5D point)
            : this(point.X, point.Y, point.Z, point.W, point.V)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="Size5D" /> class.
        /// </summary>
        /// <param name="width">The Width component of the Size.</param>
        /// <param name="height">The Height component of the Size.</param>
        /// <param name="depth">The Depth component of the Size.</param>
        /// <param name="breadth">The Breadth component of the Size.</param>
        /// <param name="length">The length.</param>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Size5D(double width, double height, double depth, double breadth, double length)
            : this()
        {
            (Width, Height, Depth, Breadth, Length) = (width, height, depth, breadth, length);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Size5D" /> class.
        /// </summary>
        /// <param name="tuple">The tuple.</param>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Size5D((double Width, double Height, double Depth, double Breadth, double Length) tuple)
            : this()
        {
            (Width, Height, Depth, Breadth, Length) = tuple;
        }
        #endregion Constructors

        #region Deconstructors
        /// <summary>
        /// Deconstruct this <see cref="Size5D" /> to a <see cref="ValueTuple{T1, T2, T3, T4, T5}" />.
        /// </summary>
        /// <param name="width">The width.</param>
        /// <param name="height">The height.</param>
        /// <param name="depth">The depth.</param>
        /// <param name="breadth">The breadth.</param>
        /// <param name="length">The length.</param>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void Deconstruct(out double width, out double height, out double depth, out double breadth, out double length) => (width, height, depth, breadth, length) = (Width, Height, Depth, Breadth, Length);
        #endregion Deconstructors

        #region Properties
        /// <summary>
        /// Gets or sets the Width component of a <see cref="Size5D" /> coordinate.
        /// </summary>
        /// <value>
        /// The width.
        /// </value>
        [DataMember(Name = nameof(Width)), XmlAttribute(nameof(Width)), SoapAttribute(nameof(Width))]
        public double Width { get; set; }

        /// <summary>
        /// Gets or sets the Height component of a <see cref="Size5D" /> coordinate.
        /// </summary>
        /// <value>
        /// The height.
        /// </value>
        [DataMember(Name = nameof(Height)), XmlAttribute(nameof(Height)), SoapAttribute(nameof(Height))]
        public double Height { get; set; }

        /// <summary>
        /// Gets or sets the Depth component of a <see cref="Size5D" /> coordinate.
        /// </summary>
        /// <value>
        /// The depth.
        /// </value>
        [DataMember(Name = nameof(Depth)), XmlAttribute(nameof(Depth)), SoapAttribute(nameof(Depth))]
        public double Depth { get; set; }

        /// <summary>
        /// Gets or sets the Breadth component of a <see cref="Size5D" /> coordinate.
        /// </summary>
        /// <value>
        /// The breadth.
        /// </value>
        [DataMember(Name = nameof(Breadth)), XmlAttribute(nameof(Breadth)), SoapAttribute(nameof(Breadth))]
        public double Breadth { get; set; }

        /// <summary>
        /// Gets or sets the Length component of a <see cref="Size5D" /> coordinate.
        /// </summary>
        /// <value>
        /// The length.
        /// </value>
        [DataMember(Name = nameof(Length)), XmlAttribute(nameof(Length)), SoapAttribute(nameof(Length))]
        public double Length { get; set; }

        /// <summary>
        /// Gets the number of components in the Vector.
        /// </summary>
        /// <value>
        /// The count.
        /// </value>
        [IgnoreDataMember, XmlIgnore, SoapIgnore]
        public int Count => 5;
        #endregion Properties

        #region Operators
        /// <summary>
        /// The operator +.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <returns>
        /// The <see cref="Size5D" />.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator +(Size5D value) => Plus(value);

        /// <summary>
        /// Add an amount to both values in the <see cref="Point5D" /> classes.
        /// </summary>
        /// <param name="augend">The original value</param>
        /// <param name="addend">The amount to add.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator +(Size5D augend, double addend) => Add(augend, addend);

        /// <summary>
        /// Add an amount to both values in the <see cref="Point5D" /> classes.
        /// </summary>
        /// <param name="augend">The original value</param>
        /// <param name="addend">The amount to add.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator +(double augend, Size5D addend) => Add(augend, addend);

        /// <summary>
        /// Add two <see cref="Size5D" /> classes together.
        /// </summary>
        /// <param name="augend">The augend.</param>
        /// <param name="addend">The addend.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator +(Size5D augend, Size5D addend) => Add(augend, addend);

        /// <summary>
        /// Add two <see cref="Size5D" /> classes together.
        /// </summary>
        /// <param name="augend">The augend.</param>
        /// <param name="addend">The addend.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D operator +(Size5D augend, Point5D addend) => Add(augend, addend);

        /// <summary>
        /// Add a <see cref="Point5D" /> and a <see cref="Size5D" /> classes together.
        /// </summary>
        /// <param name="augend">The augend.</param>
        /// <param name="addend">The addend.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D operator +(Point5D augend, Size5D addend) => Add(augend, addend);

        /// <summary>
        /// Add a <see cref="Size5D" /> to a <see cref="Vector5D" /> class.
        /// </summary>
        /// <param name="augend">The augend.</param>
        /// <param name="addend">The addend.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D operator +(Size5D augend, Vector5D addend) => Add(augend, addend);

        /// <summary>
        /// Add a <see cref="Vector5D" /> and a <see cref="Size5D" /> classes together.
        /// </summary>
        /// <param name="augend">The augend.</param>
        /// <param name="addend">The addend.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D operator +(Vector5D augend, Size5D addend) => Add(augend, addend);

        /// <summary>
        /// The operator -.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <returns>
        /// The <see cref="Size5D" />.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator -(Size5D value) => Negate(value);

        /// <summary>
        /// Subtract a <see cref="Size5D" /> from a <see cref="double" /> value.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator -(Size5D minuend, double subend) => Subtract(minuend, subend);

        /// <summary>
        /// Subtract a <see cref="double" /> value from a <see cref="Size5D" />.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator -(double minuend, Size5D subend) => Subtract(minuend, subend);

        /// <summary>
        /// Subtract a <see cref="Size5D" /> from another <see cref="Size5D" /> class.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator -(Size5D minuend, Size5D subend) => Subtract(minuend, subend);

        /// <summary>
        /// Subtract a <see cref="Size5D" /> from a <see cref="Point5D" /> class.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D operator -(Size5D minuend, Point5D subend) => Subtract(minuend, subend);

        /// <summary>
        /// Subtract a <see cref="Point5D" /> from another <see cref="Size5D" /> class.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D operator -(Point5D minuend, Size5D subend) => Subtract(minuend, subend);

        /// <summary>
        /// Subtract a <see cref="Size5D" /> from a <see cref="Vector5D" /> class.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D operator -(Size5D minuend, Vector5D subend) => Subtract(minuend, subend);

        /// <summary>
        /// Subtract a <see cref="Vector5D" /> from another <see cref="Size5D" /> class.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D operator -(Vector5D minuend, Size5D subend) => Subtract(minuend, subend);

        /// <summary>
        /// Scale a Size.
        /// </summary>
        /// <param name="multiplicand">The multiplicand.</param>
        /// <param name="multiplier">The multiplier.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator *(Size5D multiplicand, double multiplier) => Multiply(multiplicand, multiplier);

        /// <summary>
        /// Scale a point
        /// </summary>
        /// <param name="multiplicand">The multiplicand.</param>
        /// <param name="multiplier">The multiplier.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator *(double multiplicand, Size5D multiplier) => Multiply(multiplicand, multiplier);

        /// <summary>
        /// Scale a Size5D
        /// </summary>
        /// <param name="multiplicand">The Point</param>
        /// <param name="multiplier">The Multiplier</param>
        /// <returns>
        /// A Point Multiplied by the Multiplier
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator *(Size5D multiplicand, Size5D multiplier) => Multiply(multiplicand, multiplier);

        /// <summary>
        /// Scale a Point
        /// </summary>
        /// <param name="multiplicand">The Point</param>
        /// <param name="multiplier">The Multiplier</param>
        /// <returns>
        /// A Point Multiplied by the Multiplier
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D operator *(Size5D multiplicand, Point5D multiplier) => Multiply(multiplicand, multiplier);

        /// <summary>
        /// Scale a Point
        /// </summary>
        /// <param name="multiplicand">The Point</param>
        /// <param name="multiplier">The Multiplier</param>
        /// <returns>
        /// A Point Multiplied by the Multiplier
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D operator *(Point5D multiplicand, Size5D multiplier) => Multiply(multiplicand, multiplier);

        /// <summary>
        /// Scale a Vector
        /// </summary>
        /// <param name="multiplicand">The Point</param>
        /// <param name="multiplier">The Multiplier</param>
        /// <returns>
        /// A Point Multiplied by the Multiplier
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D operator *(Size5D multiplicand, Vector5D multiplier) => Multiply(multiplicand, multiplier);

        /// <summary>
        /// Scale a Vector
        /// </summary>
        /// <param name="multiplicand">The Point</param>
        /// <param name="multiplier">The Multiplier</param>
        /// <returns>
        /// A Point Multiplied by the Multiplier
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D operator *(Vector5D multiplicand, Size5D multiplier) => Multiply(multiplicand, multiplier);

        /// <summary>
        /// Divide a <see cref="Size5D" /> by a <see cref="double" /> value.
        /// </summary>
        /// <param name="dividend">The dividend.</param>
        /// <param name="divisor">The divisor.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator /(Size5D dividend, double divisor) => Divide(dividend, divisor);

        /// <summary>
        /// Divide a <see cref="double" /> by a <see cref="Size5D" /> value.
        /// </summary>
        /// <param name="dividend">The dividend.</param>
        /// <param name="divisor">The divisor.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator /(double dividend, Size5D divisor) => Divide(dividend, divisor);

        /// <summary>
        /// Divide a Size5D
        /// </summary>
        /// <param name="dividend">The Point</param>
        /// <param name="divisor">The Multiplier</param>
        /// <returns>
        /// A Point Multiplied by the Multiplier
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D operator /(Size5D dividend, Size5D divisor) => Divide(dividend, divisor);

        /// <summary>
        /// Divide a Point
        /// </summary>
        /// <param name="dividend">The Point</param>
        /// <param name="divisor">The Multiplier</param>
        /// <returns>
        /// A Point Multiplied by the Multiplier
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D operator /(Size5D dividend, Point5D divisor) => Divide(dividend, divisor);

        /// <summary>
        /// Divide a Point
        /// </summary>
        /// <param name="dividend">The Point</param>
        /// <param name="divisor">The Multiplier</param>
        /// <returns>
        /// A Point Multiplied by the Multiplier
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D operator /(Point5D dividend, Size5D divisor) => Divide(dividend, divisor);

        /// <summary>
        /// Divide a Vector
        /// </summary>
        /// <param name="dividend">The Point</param>
        /// <param name="divisor">The Multiplier</param>
        /// <returns>
        /// A Point Multiplied by the Multiplier
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D operator /(Size5D dividend, Vector5D divisor) => Divide(dividend, divisor);

        /// <summary>
        /// Divide a Vector
        /// </summary>
        /// <param name="dividend">The Point</param>
        /// <param name="divisor">The Multiplier</param>
        /// <returns>
        /// A Point Multiplied by the Multiplier
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D operator /(Vector5D dividend, Size5D divisor) => Divide(dividend, divisor);

        /// <summary>
        /// Compares two <see cref="Size5D" /> objects.
        /// The result specifies whether the values of the <see cref="Width" />, <see cref="Height" />, <see cref="Depth" /> and <see cref="Breadth" />
        /// values of the two <see cref="Size5D" /> objects are equal.
        /// </summary>
        /// <param name="left">The left.</param>
        /// <param name="right">The right.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool operator ==(Size5D left, Size5D right) => Equals(left, right);

        /// <summary>
        /// Compares two <see cref="Size5D" /> objects.
        /// The result specifies whether the values of the <see cref="Width" />, <see cref="Height" />, <see cref="Depth" /> or <see cref="Breadth" />
        /// values of the two <see cref="Size5D" /> objects are unequal.
        /// </summary>
        /// <param name="left">The left.</param>
        /// <param name="right">The right.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool operator !=(Size5D left, Size5D right) => !Equals(left, right);

        /// <summary>
        /// Converts the specified <see cref="Vector5D" /> structure to a <see cref="Size5D" /> structure.
        /// </summary>
        /// <param name="vector">The <see cref="Vector5D" /> to be converted.</param>
        /// <returns>
        /// Size - A Size equal to this Size
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static explicit operator Size5D(Vector5D vector) => new Size5D(vector.I, vector.J, vector.K, vector.L, vector.M);

        /// <summary>
        /// Explicit conversion to Vector.
        /// </summary>
        /// <param name="size">Size - the Size to convert to a Vector</param>
        /// <returns>
        /// Vector - A Vector equal to this Size
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static explicit operator Vector5D(Size5D size) => new Vector5D(size.Width, size.Height, size.Depth, size.Breadth, size.Length);

        /// <summary>
        /// Converts the specified <see cref="Point5D" /> structure to a <see cref="Size5D" /> structure.
        /// </summary>
        /// <param name="point">The <see cref="Point5D" /> to be converted.</param>
        /// <returns>
        /// Size - A Vector equal to this Size
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static explicit operator Size5D(Point5D point) => new Size5D(point.X, point.Y, point.Z, point.W, point.V);

        /// <summary>
        /// Converts the specified <see cref="Size5D" /> to a <see cref="Point5D" />.
        /// </summary>
        /// <param name="size">The size.</param>
        /// <returns>
        /// The result of the conversion.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static explicit operator Point5D(Size5D size) => new Point5D(size.Width, size.Height, size.Depth, size.Breadth, size.Length);

        /// <summary>
        /// Implicit conversion from tuple.
        /// </summary>
        /// <param name="tuple">Size - the Size to convert to a Vector</param>
        /// <returns>
        /// The result of the conversion.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static implicit operator Size5D((double Width, double Height, double Depth, double Breadth, double Length) tuple) => new Size5D(tuple);

        /// <summary>
        /// Converts the specified <see cref="Size5D" /> structure to a <see cref="ValueTuple{T1, T2, T3, T4, T5}" /> structure.
        /// </summary>
        /// <param name="size">The <see cref="Size5D" /> to be converted.</param>
        /// <returns>
        /// The result of the conversion.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static implicit operator (double Width, double Height, double Depth, double Breadth, double Length)(Size5D size) => (size.Width, size.Height, size.Depth, size.Breadth, size.Length);
        #endregion Operators

        #region Operator Backing Methods
        /// <summary>
        /// Pluses the specified value.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Plus(Size5D value) => Operations.Plus(value.Width, value.Height, value.Depth, value.Breadth, value.Length);

        /// <summary>
        /// Adds the specified augend.
        /// </summary>
        /// <param name="augend">The augend.</param>
        /// <param name="addend">The addend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Add(Size5D augend, double addend) => Operations.AddVectorUniform(augend.Width, augend.Height, augend.Depth, augend.Breadth, augend.Length, addend);

        /// <summary>
        /// Adds the specified augend.
        /// </summary>
        /// <param name="augend">The augend.</param>
        /// <param name="addend">The addend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Add(double augend, Size5D addend) => Operations.AddVectorUniform(addend.Width, addend.Height, addend.Depth, addend.Breadth, addend.Length, augend);

        /// <summary>
        /// Adds the specified augend.
        /// </summary>
        /// <param name="augend">The augend.</param>
        /// <param name="addend">The addend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Add(Size5D augend, Size5D addend) => Operations.AddVectors(augend.Width, augend.Height, augend.Depth, augend.Breadth, augend.Length, addend.Width, addend.Height, addend.Depth, addend.Breadth, addend.Length);

        /// <summary>
        /// Adds the specified augend.
        /// </summary>
        /// <param name="augend">The augend.</param>
        /// <param name="addend">The addend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D Add(Size5D augend, Point5D addend) => Operations.AddVectors(augend.Width, augend.Height, augend.Depth, augend.Breadth, augend.Length, addend.X, addend.Y, addend.Z, addend.W, addend.V);

        /// <summary>
        /// Adds the specified augend.
        /// </summary>
        /// <param name="augend">The augend.</param>
        /// <param name="addend">The addend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D Add(Point5D augend, Size5D addend) => Operations.AddVectors(augend.X, augend.Y, augend.Z, augend.W, augend.V, addend.Width, addend.Height, addend.Depth, addend.Breadth, addend.Length);

        /// <summary>
        /// Adds the specified augend.
        /// </summary>
        /// <param name="augend">The augend.</param>
        /// <param name="addend">The addend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D Add(Size5D augend, Vector5D addend) => Operations.AddVectors(augend.Width, augend.Height, augend.Depth, augend.Breadth, augend.Length, addend.I, addend.J, addend.K, addend.L, addend.M);

        /// <summary>
        /// Adds the specified augend.
        /// </summary>
        /// <param name="augend">The augend.</param>
        /// <param name="addend">The addend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D Add(Vector5D augend, Size5D addend) => Operations.AddVectors(augend.I, augend.J, augend.K, augend.L, augend.M, addend.Width, addend.Height, addend.Depth, addend.Breadth, addend.Length);

        /// <summary>
        /// Negates the specified value.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Negate(Size5D value) => Operations.Negate(value.Width, value.Height, value.Depth, value.Breadth, value.Length);

        /// <summary>
        /// Subtracts the specified minuend.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Subtract(Size5D minuend, double subend) => Operations.SubtractVectorUniform(minuend.Width, minuend.Height, minuend.Depth, minuend.Breadth, minuend.Length, subend);

        /// <summary>
        /// Subtracts the specified minuend.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Subtract(double minuend, Size5D subend) => Operations.SubtractVectorUniform(minuend, subend.Width, subend.Height, subend.Depth, subend.Breadth, subend.Length);

        /// <summary>
        /// Subtracts the specified minuend.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Subtract(Size5D minuend, Size5D subend) => Operations.SubtractVector(minuend.Width, minuend.Height, minuend.Depth, minuend.Breadth, minuend.Length, subend.Width, subend.Height, subend.Depth, subend.Breadth, subend.Length);

        /// <summary>
        /// Subtracts the specified minuend.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D Subtract(Size5D minuend, Point5D subend) => Operations.SubtractVector(minuend.Width, minuend.Height, minuend.Depth, minuend.Breadth, minuend.Length, subend.X, subend.Y, subend.Z, subend.W, subend.V);

        /// <summary>
        /// Subtracts the specified minuend.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D Subtract(Point5D minuend, Size5D subend) => Operations.SubtractVector(minuend.X, minuend.Y, minuend.Z, minuend.W, minuend.V, subend.Width, subend.Height, subend.Depth, subend.Breadth, subend.Length);

        /// <summary>
        /// Subtracts the specified minuend.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D Subtract(Size5D minuend, Vector5D subend) => Operations.SubtractVector(minuend.Width, minuend.Height, minuend.Depth, minuend.Breadth, minuend.Length, subend.I, subend.J, subend.K, subend.L, subend.M);

        /// <summary>
        /// Subtracts the specified minuend.
        /// </summary>
        /// <param name="minuend">The minuend.</param>
        /// <param name="subend">The subend.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D Subtract(Vector5D minuend, Size5D subend) => Operations.SubtractVector(minuend.I, minuend.J, minuend.K, minuend.L, minuend.M, subend.Width, subend.Height, subend.Depth, subend.Breadth, subend.Length);

        /// <summary>
        /// Multiplies the specified multiplicand.
        /// </summary>
        /// <param name="multiplicand">The multiplicand.</param>
        /// <param name="multiplier">The multiplier.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Multiply(Size5D multiplicand, double multiplier) => Operations.ScaleVector(multiplicand.Width, multiplicand.Height, multiplicand.Depth, multiplicand.Breadth, multiplicand.Length, multiplier);

        /// <summary>
        /// Multiplies the specified multiplicand.
        /// </summary>
        /// <param name="multiplicand">The multiplicand.</param>
        /// <param name="multiplier">The multiplier.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Multiply(double multiplicand, Size5D multiplier) => Operations.ScaleVector(multiplier.Width, multiplier.Height, multiplier.Depth, multiplier.Breadth, multiplier.Length, multiplicand);

        /// <summary>
        /// Multiplies the specified multiplicand.
        /// </summary>
        /// <param name="multiplicand">The multiplicand.</param>
        /// <param name="multiplier">The multiplier.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Multiply(Size5D multiplicand, Size5D multiplier) => Operations.ScaleVectorParametric(multiplicand.Width, multiplicand.Height, multiplicand.Depth, multiplicand.Breadth, multiplicand.Length, multiplier.Width, multiplier.Height, multiplier.Depth, multiplier.Breadth, multiplier.Length);

        /// <summary>
        /// Multiplies the specified multiplicand.
        /// </summary>
        /// <param name="multiplicand">The multiplicand.</param>
        /// <param name="multiplier">The multiplier.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D Multiply(Size5D multiplicand, Point5D multiplier) => Operations.ScaleVectorParametric(multiplicand.Width, multiplicand.Height, multiplicand.Depth, multiplicand.Breadth, multiplicand.Length, multiplier.X, multiplier.Y, multiplier.Z, multiplier.W, multiplier.V);

        /// <summary>
        /// Multiplies the specified multiplicand.
        /// </summary>
        /// <param name="multiplicand">The multiplicand.</param>
        /// <param name="multiplier">The multiplier.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D Multiply(Point5D multiplicand, Size5D multiplier) => Operations.ScaleVectorParametric(multiplicand.X, multiplicand.Y, multiplicand.Z, multiplicand.W, multiplicand.V, multiplier.Width, multiplier.Height, multiplier.Depth, multiplier.Breadth, multiplier.Length);

        /// <summary>
        /// Multiplies the specified multiplicand.
        /// </summary>
        /// <param name="multiplicand">The multiplicand.</param>
        /// <param name="multiplier">The multiplier.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D Multiply(Size5D multiplicand, Vector5D multiplier) => Operations.ScaleVectorParametric(multiplicand.Width, multiplicand.Height, multiplicand.Depth, multiplicand.Breadth, multiplicand.Length, multiplier.I, multiplier.J, multiplier.K, multiplier.L, multiplier.M);

        /// <summary>
        /// Multiplies the specified multiplicand.
        /// </summary>
        /// <param name="multiplicand">The multiplicand.</param>
        /// <param name="multiplier">The multiplier.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D Multiply(Vector5D multiplicand, Size5D multiplier) => Operations.ScaleVectorParametric(multiplicand.I, multiplicand.J, multiplicand.K, multiplicand.L, multiplicand.M, multiplier.Width, multiplier.Height, multiplier.Depth, multiplier.Breadth, multiplier.Length);

        /// <summary>
        /// Divides the specified dividend.
        /// </summary>
        /// <param name="dividend">The dividend.</param>
        /// <param name="divisor">The divisor.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Divide(Size5D dividend, double divisor) => Operations.DivideVectorUniform(dividend.Width, dividend.Height, dividend.Depth, dividend.Breadth, dividend.Length, divisor);

        /// <summary>
        /// Divides the specified dividend.
        /// </summary>
        /// <param name="dividend">The dividend.</param>
        /// <param name="divisor">The divisor.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Divide(double dividend, Size5D divisor) => Operations.DivideByVectorUniform(dividend, divisor.Width, divisor.Height, divisor.Depth, divisor.Breadth, divisor.Length);

        /// <summary>
        /// Divides the specified dividend.
        /// </summary>
        /// <param name="dividend">The dividend.</param>
        /// <param name="divisor">The divisor.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D Divide(Size5D dividend, Size5D divisor) => Operations.DivideVectorParametric(dividend.Width, dividend.Height, dividend.Depth, dividend.Breadth, dividend.Length, divisor.Width, divisor.Height, divisor.Depth, divisor.Breadth, divisor.Length);

        /// <summary>
        /// Divides the specified dividend.
        /// </summary>
        /// <param name="dividend">The dividend.</param>
        /// <param name="divisor">The divisor.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D Divide(Size5D dividend, Point5D divisor) => Operations.DivideVectorParametric(dividend.Width, dividend.Height, dividend.Depth, dividend.Breadth, dividend.Length, divisor.X, divisor.Y, divisor.Z, divisor.W, divisor.V);

        /// <summary>
        /// Divides the specified dividend.
        /// </summary>
        /// <param name="dividend">The dividend.</param>
        /// <param name="divisor">The divisor.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D Divide(Point5D dividend, Size5D divisor) => Operations.DivideVectorParametric(dividend.X, dividend.Y, dividend.Z, dividend.W, dividend.V, divisor.Width, divisor.Height, divisor.Depth, divisor.Breadth, divisor.Length);

        /// <summary>
        /// Divides the specified dividend.
        /// </summary>
        /// <param name="dividend">The dividend.</param>
        /// <param name="divisor">The divisor.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D Divide(Size5D dividend, Vector5D divisor) => Operations.ScaleVectorParametric(dividend.Width, dividend.Height, dividend.Depth, dividend.Breadth, dividend.Length, divisor.I, divisor.J, divisor.K, divisor.L, divisor.M);

        /// <summary>
        /// Divides the specified dividend.
        /// </summary>
        /// <param name="dividend">The dividend.</param>
        /// <param name="divisor">The divisor.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D Divide(Vector5D dividend, Size5D divisor) => Operations.DivideVectorParametric(dividend.I, dividend.J, dividend.K, dividend.L, dividend.M, divisor.Width, divisor.Height, divisor.Depth, divisor.Breadth, divisor.Length);

        /// <summary>
        /// Determines whether the specified <see cref="object" />, is equal to this instance.
        /// </summary>
        /// <param name="obj">The <see cref="object" /> to compare with this instance.</param>
        /// <returns>
        ///   <see langword="true"/> if the specified <see cref="object" /> is equal to this instance; otherwise, <see langword="false"/>.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public override bool Equals([AllowNull] object obj) => obj is Point2D d && Equals(d);

        /// <summary>
        /// The equals.
        /// </summary>
        /// <param name="other">An object to compare with this object.</param>
        /// <returns>
        /// The <see cref="bool" />.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool Equals(Size5D other) => (Width == other.Width) && (Height == other.Height) && (Depth == other.Depth) && (Breadth == other.Breadth) && (Length == other.Length);

        /// <summary>
        /// Converts to valuetuple.
        /// </summary>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public (double Width, double Height, double Depth, double Breadth, double Length) ToValueTuple() => (Width, Height, Depth, Breadth, Length);

        /// <summary>
        /// Froms the value tuple.
        /// </summary>
        /// <param name="tuple">The tuple.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D FromValueTuple((double Width, double Height, double Depth, double Breadth, double Length) tuple) => new Size5D(tuple.Width, tuple.Height, tuple.Depth, tuple.Breadth, tuple.Length);

        /// <summary>
        /// Converts to size5D.
        /// </summary>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Size5D ToSize5D() => new Size5D(Width, Height, Depth, Breadth, Length);

        /// <summary>
        /// Converts to size5D.
        /// </summary>
        /// <param name="size">The size.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Size5D FromSize5D(Size5D size) => new Size5D(size.Width, size.Height, size.Depth, size.Breadth, size.Length);

        /// <summary>
        /// Converts to vector5D.
        /// </summary>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Vector5D ToVector5D() => new Vector5D(Width, Height, Depth, Breadth, Length);

        /// <summary>
        /// Converts to Vector5D.
        /// </summary>
        /// <param name="vector">The vector.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector5D FromVector5D(Vector5D vector) => new Vector5D(vector.I, vector.J, vector.K, vector.L, vector.M);

        /// <summary>
        /// Converts to point5D.
        /// </summary>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Point5D ToPoint5D() => new Point5D(Width, Height, Depth, Breadth, Length);

        /// <summary>
        /// Converts to Point5D.
        /// </summary>
        /// <param name="point">The point.</param>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Point5D FromPoint5D(Point5D point) => new Point5D(point.X, point.Y, point.Z, point.W, point.V);
        #endregion

        #region Factories
        /// <summary>
        /// Parse a string for a <see cref="Size5D" /> value.
        /// </summary>
        /// <param name="source"><see cref="string" /> with <see cref="Size5D" /> data</param>
        /// <returns>
        /// Returns an instance of the <see cref="Size5D" /> struct converted
        /// from the provided string using the <see cref="CultureInfo.InvariantCulture" />.
        /// </returns>
        [ParseMethod]
        public static Size5D Parse(string source) => Parse(source, CultureInfo.InvariantCulture);

        /// <summary>
        /// Parse a string for a <see cref="Size5D" /> value.
        /// </summary>
        /// <param name="source"><see cref="string" /> with <see cref="Size5D" /> data</param>
        /// <param name="formatProvider">The provider.</param>
        /// <returns>
        /// Returns an instance of the <see cref="Size5D" /> struct converted
        /// from the provided string using the <see cref="CultureInfo.InvariantCulture" />.
        /// </returns>
        public static Size5D Parse(string source, IFormatProvider formatProvider)
        {
            var tokenizer = new Tokenizer(source, formatProvider);
            var firstToken = tokenizer.NextTokenRequired();

            // The token will already have had whitespace trimmed so we can do a simple string compare.
            var value = firstToken == nameof(Empty) ? Empty : new Size5D(
                Convert.ToDouble(firstToken, formatProvider),
                Convert.ToDouble(tokenizer.NextTokenRequired(), formatProvider),
                Convert.ToDouble(tokenizer.NextTokenRequired(), formatProvider),
                Convert.ToDouble(tokenizer.NextTokenRequired(), formatProvider),
                Convert.ToDouble(tokenizer.NextTokenRequired(), formatProvider)
                );

            // There should be no more tokens in this string.
            tokenizer.LastTokenRequired();
            return value;
        }
        #endregion Factories

        #region Standard Methods
        /// <summary>
        /// Get the hash code.
        /// </summary>
        /// <returns>
        /// The <see cref="int" />.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public override int GetHashCode() => HashCode.Combine(Width, Height, Depth, Breadth, Length);

        /// <summary>
        /// Converts to string.
        /// </summary>
        /// <returns>
        /// A <see cref="string" /> that represents this instance.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public override string ToString() => ToString("R" /* format string */, CultureInfo.InvariantCulture /* format provider */);

        /// <summary>
        /// Creates a string representation of this <see cref="Size5D" /> struct based on the format string
        /// and IFormatProvider passed in.
        /// If the provider is null, the CurrentCulture is used.
        /// See the documentation for IFormattable for more information.
        /// </summary>
        /// <param name="format">The format.</param>
        /// <param name="formatProvider">The format provider.</param>
        /// <returns>
        /// A string representation of this <see cref="Size5D" />.
        /// </returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public string ToString(string format, IFormatProvider formatProvider)
        {
            if (this == null) return nameof(Size5D);
            var s = Tokenizer.GetNumericListSeparator(formatProvider);
            return $"{nameof(Size5D)}({nameof(Width)}:{Width.ToString(format, formatProvider)}{s} {nameof(Height)}:{Height.ToString(format, formatProvider)}{s} {nameof(Depth)}:{Depth.ToString(format, formatProvider)}{s} {nameof(Breadth)}:{Breadth.ToString(format, formatProvider)}{s} {nameof(Length)}:{Length.ToString(format, formatProvider)})";
        }

        /// <summary>
        /// Gets the debugger display.
        /// </summary>
        /// <returns></returns>
        [DebuggerStepThrough]
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private string GetDebuggerDisplay() => ToString();
        #endregion
    }
}

redpajama_set_name: RedPajamaGithub