<?xml version="1.0" encoding="utf-8"?>
<!--
This file contains the text of the inaugural address made by John F. Kennedy after being sworn in as the thirty-fifth President of the United States on January 20, 1961. This text is in the public domain.
-->
<flow:TextFlow xmlns:flow="http://ns.adobe.com/textLayout/2008" fontFamily="Times New Roman">
	<flow:p><flow:span>Ask Not What Your Coun­try Can Do For You speech</flow:span></flow:p>
	<flow:p><flow:span>Vice Pres­i­dent John­son, Mr. Speak­er, Mr. Chief Jus­tice, Pres­i­dent Eisen­how­er, Vice Pres­i­dent Nix­on, Pres­i­dent Tru­man, rev­er­end cler­gy, fel­low cit­i­zens, we ob­serve to­day not a vic­to­ry of par­ty, but a cel­e­bra­tion of free­dom - sym­bol­iz­ing an end, as well as a be­gin­ning - sig­ni­fy­ing re­new­al, as well as change. For I have sworn be­fore you and Al­mighty God the same sol­emn oath our fore­bears pre­scribed near­ly a cen­tu­ry and three quar­ters ago.</flow:span></flow:p>
	<flow:p><flow:span>The world is very dif­fer­ent now. For man holds in his mor­tal hands the pow­er to abol­ish all forms of hu­man pov­er­ty and all forms of hu­man life. And yet the same rev­o­lu­tion­ary be­liefs for which our fore­bears fought are still at is­sue around the globe - the be­lief that the rights of man come not from the gen­er­os­i­ty of the state, but from the hand of God.</flow:span></flow:p>
	<flow:p><flow:span>We dare not for­get to­day that we are the heirs of that first rev­o­lu­tion. Let the word go forth from this time and place, to friend and foe alike, that the torch has been passed to a new gen­er­a­tion of Amer­i­cans - born in this cen­tu­ry, tem­pered by war, dis­ci­plined by a hard and bit­ter peace, proud of our an­cient her­i­tage - and un­will­ing to wit­ness or per­mit the slow un­do­ing of those hu­man rights to which this Na­tion has al­ways been com­mit­ted, and to which we are com­mit­ted to­day at home and around the world.</flow:span></flow:p>
	<flow:p><flow:span>Let ev­ery na­tion know, wheth­er it wish­es us well or ill, that we shall pay any price, bear any bur­den, meet any hard­ship, sup­port any friend, op­pose any foe, in or­der to as­sure the sur­viv­al and the suc­cess of lib­er­ty.</flow:span></flow:p>
	<flow:p><flow:span>This much we pledge - and more. </flow:span></flow:p>
	<flow:p><flow:span>To those old al­lies whose cul­tur­al and spir­i­tu­al or­i­gins we share, we pledge the loy­al­ty of faith­ful friends. Unit­ed, there is lit­tle we can­not do in a host of co­op­er­a­tive ven­tures. Di­vid­ed, there is lit­tle we can do - for we dare not meet a pow­er­ful chal­lenge at odds and split asun­der.</flow:span></flow:p>
	<flow:p><flow:span>To those new States whom we wel­come to the ranks of the free, we pledge our word that one form of co­lo­nial con­trol shall not have passed away mere­ly to be re­placed by a far more iron tyr­an­ny. We shall not al­ways ex­pect to find them sup­port­ing our view. But we shall al­ways hope to find them strong­ly sup­port­ing their own free­dom - and to re­mem­ber that, in the past, those who fool­ish­ly sought pow­er by rid­ing the back of the ti­ger end­ed up in­side.</flow:span></flow:p>
	<flow:p><flow:span>To those peo­ples in the huts and vil­lag­es across the globe strug­gling to break the bonds of mass mis­ery, we pledge our best ef­forts to help them help them­selves, for what­ev­er pe­ri­od is re­quired - not be­cause the Com­mu­nists may be do­ing it, not be­cause we seek their votes, but be­cause it is right. If a free so­ci­ety can­not help the many who are poor, it can­not save the few who are rich.</flow:span></flow:p>
	<flow:p><flow:span>To our sis­ter re­pub­lics south of our bor­der, we of­fer a spe­cial pledge - to con­vert our good words in­to good deeds - in a new al­li­ance for prog­ress - to as­sist free men and free gov­ern­ments in cast­ing off the chains of pov­er­ty. But this peace­ful rev­o­lu­tion of hope can­not be­come the prey of hos­tile pow­ers. Let all our neigh­bours know that we shall join with them to op­pose ag­gres­sion or sub­ver­sion any­where in the Amer­i­cas. And let ev­ery oth­er pow­er know that this Hemi­sphere in­tends to re­main the mas­ter of its own house.</flow:span></flow:p>
	<flow:p><flow:span>To that world as­sem­bly of sov­er­eign states, the Unit­ed Na­tions, our last best hope in an age where the in­stru­ments of war have far out­paced the in­stru­ments of peace, we re­new our pledge of sup­port - to pre­vent it from be­com­ing mere­ly a fo­rum for in­vec­tive - to strength­en its shield of the new and the weak - and to en­large the ar­ea in which its writ may run.</flow:span></flow:p>
	<flow:p><flow:span>Finally, to those nations who would make themselves our adversary, we offer not a pledge but a request: that both sides begin anew the quest for peace, before the dark powers of destruction unleashed by science engulf all humanity in planned or accidental self-destruction. </flow:span></flow:p>
	<flow:p><flow:span>We dare not tempt them with weak­ness. For on­ly when our arms are suf­fi­cient be­yond doubt can we be cer­tain be­yond doubt that they will nev­er be em­ployed.</flow:span></flow:p>
	<flow:p><flow:span>But nei­ther can two great and pow­er­ful groups of na­tions take com­fort from our pres­ent course - both sides over­bur­dened by the cost of mod­ern weap­ons, both right­ly alarmed by the steady spread of the dead­ly at­om, yet both rac­ing to al­ter that un­cer­tain bal­ance of ter­ror that stays the hand of man­kind's fi­nal war.</flow:span></flow:p>
	<flow:p><flow:span>So let us be­gin anew - re­mem­ber­ing on both sides that ci­vil­i­ty is not a sign of weak­ness, and sin­cer­i­ty is al­ways sub­ject to proof. Let us nev­er ne­go­ti­ate out of fear. But let us nev­er fear to ne­go­ti­ate.</flow:span></flow:p>
	<flow:p><flow:span>Let both sides ex­plore what prob­lems unite us in­stead of be­la­bour­ing those prob­lems which di­vide us.</flow:span></flow:p>
	<flow:p><flow:span>Let both sides, for the first time, for­mu­late se­ri­ous and pre­cise pro­pos­als for the in­spec­tion and con­trol of arms - and bring the ab­so­lute pow­er to de­stroy oth­er na­tions un­der the ab­so­lute con­trol of all na­tions.</flow:span></flow:p>
	<flow:p><flow:span>Let both sides seek to in­voke the won­ders of sci­ence in­stead of its ter­rors. To­geth­er let us ex­plore the stars, con­quer the des­erts, erad­i­cate dis­ease, tap the ocean depths, and en­cour­age the arts and com­merce.</flow:span></flow:p>
	<flow:p><flow:span>Let both sides unite to heed in all cor­ners of the earth the com­mand of Isa­iah - to "un­do the heavy bur­dens -. and to let the op­pressed go free." </flow:span></flow:p>
	<flow:p><flow:span>And if a beach­head of co­op­er­a­tion may push back the jun­gle of sus­pi­cion, let both sides join in cre­at­ing a new en­dea­v­our, not a new bal­ance of pow­er, but a new world of law, where the strong are just and the weak se­cure and the peace pre­served.</flow:span></flow:p>
	<flow:p><flow:span>All this will not be fin­ished in the first 100 days. Nor will it be fin­ished in the first 1,000 days, nor in the life of this Ad­min­is­tra­tion, nor even per­haps in our life­time on this plan­et. But let us be­gin.</flow:span></flow:p>
	<flow:p><flow:span>In your hands, my fel­low cit­i­zens, more than in mine, will rest the fi­nal suc­cess or fail­ure of our course. Since this coun­try was found­ed, each gen­er­a­tion of Amer­i­cans has been sum­moned to give tes­ti­mo­ny to its na­tion­al loy­al­ty. The graves of young Amer­i­cans who an­swered the call to ser­vice sur­round the globe.</flow:span></flow:p>
	<flow:p><flow:span>Now the trum­pet sum­mons us again - not as a call to bear arms, though arms we need; not as a call to bat­tle, though em­bat­tled we are - but a call to bear the bur­den of a long twi­light strug­gle, year in and year out, "re­joic­ing in hope, pa­tient in trib­u­la­tion" - a strug­gle against the com­mon en­e­mies of man: tyr­an­ny, pov­er­ty, dis­ease, and war it­self.</flow:span></flow:p>
	<flow:p><flow:span>Can we forge against these en­e­mies a grand and glob­al al­li­ance, North and South, East and West, that can as­sure a more fruit­ful life for all man­kind? Will you join in that his­tor­ic ef­fort</flow:span></flow:p>
	<flow:p><flow:span>In the long his­to­ry of the world, on­ly a few gen­er­a­tions have been grant­ed the role of de­fend­ing free­dom in its hour of max­i­mum dan­ger. I do not shank from this re­spon­si­bil­i­ty - I wel­come it. I do not be­lieve that any of us would ex­change plac­es with any oth­er peo­ple or any oth­er gen­er­a­tion. The en­er­gy, the faith, the de­vo­tion which we bring to this en­dea­v­our will light our coun­try and all who serve it -- and the glow from that fire can tru­ly light the world.</flow:span></flow:p>
	<flow:p><flow:span>And so, my fel­low Amer­i­cans: ask not what your coun­try can do for you - ask what you can do for your coun­try.</flow:span></flow:p>
	<flow:p><flow:span>My fel­low cit­i­zens of the world: ask not what Amer­i­ca will do for you, but what to­geth­er we can do for the free­dom of man.</flow:span></flow:p>
	<flow:p><flow:span>Fi­nal­ly, wheth­er you are cit­i­zens of Amer­i­ca or cit­i­zens of the world, ask of us the same high stan­dards of strength and sac­ri­fice which we ask of you. With a good con­science our on­ly sure re­ward, with his­to­ry the fi­nal judge of our deeds, let us go forth to lead the land we love, ask­ing His bless­ing and His help, but know­ing that here on earth God's work must tru­ly be our own.</flow:span></flow:p>
</flow:TextFlow>
