text:
Home / Business / News / State & National
Georgia Congressional Delegation Calls for Federal Review of Proposed State Department Training Facility
Business, News, State & National July 8, 2015 , by Lisa Pritchard
Cite concerns over lack of accountability, transparency in decision-making process
WASHINGTON, D.C. – U.S. Senators Johnny Isakson (R-GA) and David Perdue (R-GA) along with several member of Georgia's U.S. House of Representatives delegation are calling for a federal review of a Department of State proposal to construct a costly new training center from scratch in Virginia instead of using an established federal training facility in Georgia that could save taxpayers millions of dollars.
The proposed Virginia location for a training center for Foreign Service personnel would require taxpayers to fund the construction of an entirely new facility – a decision that the Office of Management and Budget admits was made by the Obama administration without the necessary cost-benefit analysis of options.
Senators Isakson and Perdue are calling on the U.S. Government Accountability Office (GAO) to conduct a complete, independent analysis of all options for meeting the State Department's training needs, including augmenting an existing facility – the Federal Law Enforcement Training Center, or FLETC for short, in Brunswick, Ga. – that the Georgia delegation argues could achieve significant cost savings.
"As stewards of taxpayer dollars, we want to improve diplomatic security training efforts in a cost-effective, timely manner," writes the Georgia Congressional delegation in a letter to the GAO. "We believe a thorough and impartial review of proposals is necessary to determine the option that best addresses State's needs in a fiscally responsible manner."
In a 2008 report to Congress, the State Department determined it needed to consolidate its existing security training facilities to improve instructional efficiency and to provide training to an estimated 9,000-10,000 Diplomatic Security and other State personnel.
The Department of State announced its interest in moving forward with plans to construct the new Foreign Affairs Security Training Center, known as FAST-C, in Blackstone, Va.
The State Department's initial proposal for the construction of FAST-C was estimated to cost over $950 million. The State Department later reduced the scope of the project and lowered the estimated cost to $413 million.
Senators Isakson, Perdue and members of the Georgia delegation are calling for a thorough and impartial review of the State Department's existing proposals for its training center given the vast cost difference based on estimates by the State Department and the Department of Homeland Security between constructing the facility from scratch in Blackstone, Va., at the cost of $413 million, compared to estimated $272 million to retrofit the existing training center in Georgia.
"We have concerns that this scaled down version leaves critical infrastructure needs, such as boarding, medical, dining, and recreational facilities unaddressed," they continued."We are also concerned that costs would likely increase significantly after the initial groundbreaking to address these gaps in infrastructure, and potentially additional training needs.
"The proposals we have seen for FLETC and FAST-C vary considerably in cost, scope, and projected completion time. We believe that due to these significant differences, an impartial review is imperative before the administration moves forward with either option. As such, we respectfully request that the Government Accountability Office (GAO) review both State's FAST-C proposal and the DHS proposal to expand FLETC's Glynco site to meet State's requirements."
A copy of the letter from Senators Isakson and Perdue along with U.S. Representatives Earl L. "Buddy" Carter (R-GA-01), Sanford Bishop, (D-GA-02), Lynn Westmoreland, (R-GA-03), Tom Price, (R-GA-06), Rob Woodall, (R-GA-07), Austin Scott, (R-GA-08), Jody Hice, (R-GA-10), Rick Allen, (R-GA-12), Barry Loudermilk, (R-GA-11), David Scott, (D-GA-13), and Tom Graves, (R-GA-14), to U.S. Government Accountability Office Comptroller General Gene Dodaro is available here.
In 2013, the Department of Homeland Security (DHS) submitted a proposal to the Office of Management and Budget (OMB) to service State's training needs by augmenting the Federal Law Enforcement Training Center (FLETC), in Brunswick, Ga., which provides security training for DHS and 95 federal partner organizations, including the State Department, as well as state and local law enforcement agencies. In its 2013 proposal to OMB, DHS included the construction of new buildings, weapons ranges, and driving tracks to meet the requirements of State's original FAST-C master plan. FLETC estimated that this new construction would cost $272 million. By leveraging its existing facilities to meet State's training needs, FLETC estimates its proposal could also achieve significant cost savings over the long term.
In April 2014, the Administration confirmed that it planned to adopt the State Department's proposal to build FAST-C in Blackstone, Va. However, in a meeting with Senate staff in May 2015, OMB explained that the State Department never provided the necessary information to OMB, or to FLETC, to allow for an accurate comparison of the two options despite OMB making the specific request that it do so. In that same meeting, OMB stated that the State Department has "artificially constrained the analysis" of the FAST-C proposal, and that OMB ultimately chose to simply defer the decisions to the State Department. It appears therefore that OMB failed to conduct a sufficiently rigorous analysis, in significant part due to a lack of cooperation by the State Department.
« Previous Article Georgia Congressional Delegation Calls for Federal Review of Proposed State Department Training Facility
Next Article » Rabies Raccoon Confirmation
Congress Georgia


text:
Fine Art Archive
MAYDAY / The Art of Shepard Fairey
168 pages, Hardcover, 9 1/2" x 12 1/4" (241 x 311 mm)
134 color illustrations, English
Signed by Shepard Fairey
The final exhibition before the closing of New York's seminal Deitch Projects, MAYDAY is simultaneously a call for heightened awareness and a celebration of the rebirth embodied in revolutionary movements.
MAYDAY — The Art of Shepard Fairey is published as a celebration of an evocative collection of paintings from one of the most important artists of our time. Portraits of advocates of the working class and oppressed define the collection. Fairey stakes the claim that artists, musicians and writers such as Joe Strummer, Jean Michel Basquiat and Cornel West all have parts to play in stimulating response to injustice.
With energy and urgency befitting the title MAYDAY, Fairey captures the radical spirit of his subjects, using portraiture to celebrate the artists, musicians and political activists he most admires. Says Fairey, "These people I'm portraying were all revolutionary, in one sense or another. They started out on the margins of culture and ended up changing the mainstream. When we celebrate big steps that were made in the past, it reminds us that big steps can be made in the future."
In Fairey's mind, the persistence of difficulties in the political, environmental, economic, and cultural arenas points to the definition of Mayday as a distress signal: "By now we thought we would be in post-Bush utopia, but we're still having to call attention to these problems." Like any mayday call, however, the sounding of the alarm also brings hope for help on the way. "If we stay silent, there's no hope," Fairey muses. "But if we make noise, if we put our ideas out there, then maybe we can make a change like the people in the portraits have done."
Art Exhibitions / Murals
Image Release / Permission
Obey Giant Store
Press / Media / Interview
Speaking / Appearance Requests
Copyright © 1995-2020 • All Rights Reserved

redpajama_set_name: RedPajamaCommonCrawl


text:
Narrow Boat By L T C Rolt
by L T C Rolt
Take a trip down the waterways of England during their hey-day
Narrow Boat Summary
Customer Reviews - Narrow Boat
About L T C Rolt
L. T. C. ROLT trained as an engineer, but his fame rests on his classic biographies of Brunel, Telford, Trevithick, and the Stephensons, his superb volumes of autobiography (Landscape with Machines, Landscape with Canals, and Landscape with Figures), his volumes of transport history, and Red for Danger, an account of railway disasters of Britain. He founded the Inland Waterways Association and was instrumental in encouraging interest in Britain's industrial heritage at Tal-y-llyn and elsewhere.
L T C Rolt


Elevate your beverage experience while you cheer on your NC State Wolfpack with this New Can Insulator with pocket and opener.
NC_State_Wolfpack_New_Can_Insulator_with_Pocket_And_Opener http://images.fanatics.com/lf http://dmimages.ff.p10/chains/2993581.txt false We are unable to customize this item with the text you have entered. Please try a different entry again. Your current entry cannot be processed due to guidelines for past and present player names. Please create a new entry.


Ever wonder why other people seem happier than you?
You take a look around and notice that people are smiling and laughing, and things seem to be going their way.
Does it feels like you're struggling along, just trying to make it through the day? You tell yourself that others aren't really that happy – it's just an illusion.
That could be true, OR you could be sabotaging your own growth and development. But if you pay attention to your thoughts and actions, it can become clear that you are in control of how you feel.
So instead of holding yourself back, focus your energy on living positively. After all, happy people do have a different way of looking at things.
They never forget to be GRATEFUL.
In fact, gratitude may be one of the most overlooked tools that we all have access to every day. Cultivating gratitude doesn't cost any money and it certainly doesn't take much time, but the benefits are enormous.
Here are 5 phrases grateful people never forget, try them, use them, see what changes.
"My gratitude opens the door to more relationships." Not only does saying "thank you" constitute good manners, but showing appreciation can help you win new friends.
"Showing gratitude improves my physical health." Not surprisingly, grateful people are also more likely to take care of their health. They exercise more often and are more likely to attend regular check-ups with their doctors, which is likely to contribute to further longevity.
"Through gratitude I improve my psychological health." Gratitude reduces a multitude of toxic emotions, ranging from envy and resentment to frustration and regret.
"Gratitude enhances empathy and reduces aggression towards my loved ones." Grateful people are more likely to behave in a prosocial manner, even when others behave less kind.
"Gratitude improves my self-esteem." Gratitude increases one's self-esteem, which is an essential component to optimal performance. Some studies have shown that gratitude reduces social comparisons. Rather than becoming resentful toward people who have more money or better jobs – which is a major factor in reduced self-esteem- grateful people are able to appreciate other people's accomplishments.
So there you have it, 5 different thoughts to change the way you feel about life. We all have the ability and opportunity to cultivate gratitude. Simply take a few moments to focus on all that you have – rather than complain about all the things you think you deserve. Developing an "attitude of gratitude" is one of the simplest ways to improve your satisfaction with life.


Payable Accommodation will be Provided in the college to the Participants.
Lunch and refreshments will be Free of cost.
The College is Situated at Perundurai , Erode.
Neareast Railway Station: Erode Railway Station & Perundurai Railway station.
The college bus is Available on 11.02.2019 from 6.00 pm to 7.15 pm & 12.02.2019 from 6.30 am to 7.30 am at Perundurai bus stand.


On Monday the focus of the baby yoga session was to concentrate on our breathing. We stretched and sat and used deep slow breaths which made us all feel very relaxed. These sessions are great fun for all the children and they vary every week so the children remain motivated and interested. As many of our children do not attend on a Monday, we try to incorporate some of the ideas and activities that are used during these sessions, into our daily routines, thus giving all of the children the opportunity to experience yoga.
The mud kitchen has been a very busy area this week, making pizzas, pastries and serving worm ice creams, yum yum! Now that the summer appears to have finally arrived we will be making much more use of our outside area by adding things to the mud kitchen and water wall. The summer house may be turned into a beach hut or a flower shop or even an ice cream kiosk. Let's hope the sun comes out and stays out, for what is, for some of the children, their final half term with us.
Many of the children have been practising their physical techniques using hula hoops and stilts this week. It is interesting to watch the different techniques that they use to try and balance on small stilts or balancing beams and to keep the hula hoop in the air for more than a couple of seconds.
We seem to have a few budding hairdressers at Squirrels with the hairdressing set being requested on a daily basis. Playing hairdressers, shops, garages and many other games gives a variety of opportunities for the children to develop other skills. Appointments have to be made and written down, numbers are usually given for a place in the queue, money is taken and change given, we have to take turns, the waiting area has to be decorated and we often need to count out chairs for the visiting clients.
We have been looking at new words this week which is something we try to do each week. A child asked if we could sing a particular song. We talked about it being a "request" and discussed what that meant. Interestingly another child misheard and thought we had asked for the meaning of the word "quest". She then accurately described this as going on an adventure to find something. What followed was a lively discussion on where we would like to go on an adventure and what we might be looking for.


I've been making this dressing on the regular lately, I use it as a creamy moreish dressing for salads & drizzled over roasted veggies like butternut squash or cauliflower. It's super easy to make, you just need a blender to blitz it all together.
Add all of the ingredients to the blender and blitz for a couple of minutes until smooth.
Pour and serve over your dish of choice.
Keeps in the fridge, covered for about 4 days.
I can't resist a colourful display of heirloom tomatoes, their pretty tones and knobbly shapes tempt me so. Summer time is the best time for tomatoes of any description as they are at their sweetest & juiciest. In Ireland it's really the only time of year that you will get any kind of a crop from your garden or greenhouse. I have a few pots growing in my patio garden at present but am yet to reap the rewards. I will definitely revisit this recipe once again once my home crop appears.
Lay the tomatoes out on a serving platter. Tear the mozzarella into bite size pieces and scatter over the top of the tomatoes.
In a separate bowl, whisk the olive oil, balsamic vinegar, garlic, sea-salt and black pepper together. Pour the dressing over the top of the salad.
Scatter the torn oregano over the top and serve.
Pea & mint soup is the perfect Summer soup, light, fresh and full of flavour. It makes for a great light meal or starter. Peas are full of fibre which helps you feel full and regulates blood sugar levels so you don't have blood sugar crashes and crave sugary foods. Peas are also a good source of minerals such as calcium, potassium, magnesium and iron. Mint is a digestive aid and is a really easy herb to grow in your own garden even if you only have space for a couple of pots.
Heat the olive oil in a saucepan, add the onion and garlic and fry until the onion has softened. Add the potato and vegetable stock and some seasoning, bring to the boil. Turn down the heat and continue to simmer for about 15 minutes.
Add the peas and mint and cook for a further 3 minutes, no longer, as you want to keep the vibrant green colour.
Puree the soup using a stick blender, taste and add further seasoning if necessary.


text:
Democratic Amendments to FY2016 Republican budget
Democratic Amendments to FY 2016 Republican budget »
On March 19, 2015, the House Budget Committee approved the Republican fiscal year 2016 budget that is a badly misguided recipe for national decline. It weakens the American middle class and chops down the ladders of opportunity that help hard-working Americans get ahead. It makes it harder to buy a home or pay for college, causes millions of struggling Americans to fall deeper into poverty, and makes it harder to have a secure retirement. It does nothing to help those Americans looking for jobs. It does nothing to boost the paychecks of working Americans, whose wages have stagnated for decades as the economic gains from their hard work have increasingly flowed to those at the highest income levels. This budget, instead of reversing that trend, makes it worse. It redistributes income away from the American middle class and those striving to join the middle class and directs it to the top one percent. The budget deliberately ignores the growing mountain of evidence that trickledown economics has been a miserable failure, having boosted nothing but budget deficits and the incomes of the already wealthy. The budget also disinvests in America by slashing our nation's commitments to education, research, infrastructure, and other crucial drivers of economic prosperity. And its phony claim of reaching "balance" is built on a shaky foundation of huge gimmicks. All in all, the budget rigs the rules to favor the wealthy and special interests at the expense of everyone else.
Budget Committee Democrats offered 27 different amendments to improve the budget by helping American families by increasing paychecks and protecting the middle class from tax increases, putting Americans back to work in the short-term, growing the economy through wise investments, protecting government guarantees to our seniors, preserving the safety net for those who need it, and ensuring truth and transparency in budgeting.
None of the amendments would have increased the deficit and one would have reduced the deficit. The amendments offset any proposed spending or tax breaks for working families by cutting unproductive special interest tax loopholes for the wealthiest and the well connected – including subsidies for big oil companies, egregious tax breaks such as tax deductions for corporate jets, and closing tax loopholes in the U.S. international corporate tax system that result in fewer American jobs. Republicans rejected every Democratic amendment. Following is a description of the amendments. The Appendix at the end includes the text of each amendment and each roll call vote tally.
1 Boost Paychecks of the Middle Class and Those Working to Get into the Middle Class by Providing Tax Relief for Working Americans, Supporting Worker Paychecks over CEO Bonuses Van Hollen
2 Protect the American Middle Class from Tax Increases Pocan
3 Reject Sequester Cuts to Defense and Non-Defense Spending Norcross
4 Preventing the End of Medicare as We Know It Lujan-Grisham
5 Protect Medicaid for Children, Seniors, and People with Disabilities Dingell
6 Protect Tax Credits to Keep Health Coverage Affordable Pascrell
7 Protect Nutrition Assistance Moore
8 National Strategy to Eradicate Poverty and Increase Opportunity Lee
9 Protect Scientific Jobs and Provide a National Investment in Biomedical Research Castor
10 Protect Access to Primary Care in Medicaid and Medicare McDermott
11 Fully Fund VA Programs and Protect them from Future Government Shutdowns Moulton
12 Adopt Comprehensive Immigration Reform Yarmuth
13 Accelerating Growth in U.S. Manufacturing Ryan
14 Protect Consumers from Abusive Financial Practices Lieu
15 Protect Help with Prescription Drug Costs and Other Valuable Medicare Benefits for Seniors Lujan-Grisham
17 Protect Social Security Benefits from Cuts Van Hollen
18 Invest in America's Transportation Infrastructure Castor
19 Increase Effectiveness of the Earned Income Tax Credit Moore
20 Lower Student Debt by Refinancing Student Loans and Protecting Pell Grants and Student Loan Benefits Pocan
21 Importance of Raising the Minimum Wage Yarmuth
22 Promote Early Childhood Development McDermott
23 Truth in Budgeting Regarding Affordable Care Act Savings and Expiring Tax Provisions Pascrell
Truth in Budgeting - Preventing the Abuse of the "Overseas Contingency Operations" Designation to Skirt Funding Caps
Van Hollen
25 Eliminate Overseas Contingency Operations Funding Lee
26 Improving the Availability of Long-Term Care Services and Supports for Seniors and Other Americans Dingell
27 Supporting Infrastructure Investment Norcross
28 Preparing Students for 21st Century Jobs Moulton
Boost Paychecks of the Middle Class and Those Working to Get into the Middle Class by Providing Tax Relief for Working Americans, and Supporting Worker Paychecks over CEO Bonuses
(Lead Sponsor: Rep. Van Hollen)
This amendment creates a deficit-neutral reserve fund to cut taxes on the middle class and incentivize business to boost paychecks, states the sense of the House to pass the CEO-Employee Paycheck Fairness Act, and amends the budget to improve and extend the American Opportunity Tax Credit, the Earned Income Tax Credit, and the Child Tax Credit.
A YES vote boosts middle-class paychecks by cutting taxes for American workers and incentivizing businesses to raise their workers' wages. A NO vote rejects higher pay and tax cuts for workers, two-earner households, and families paying child-care expenses.
Vote Tally Back to top
Protect the American Middle Class from Tax Increases
(Lead Sponsor: Rep. Pocan)
This amendment opposes tax increases on the middle class. The Republican budget green-lights an average tax increase of $2,000 for middle-class families in order to finance a tax reform plan that reduces the top marginal tax rate to 25 percent.
A YES vote protects taxpayers making less than $200,000 ($250,000 for couples) from paying higher taxes to finance lower tax rates for high-income taxpayers. A NO vote supports taxing the middle class in order to finance lower tax rates for the wealthy.
Reject Sequester Cuts to Defense and Non-Defense Spending
(Lead Sponsor: Rep. Norcross)
This deficit-neutral amendment rejects the inadequate levels of defense and non-defense discretionary spending set by the sequester for 2016, bringing non-defense funding up to the pre-sequester level and defense to the President's level.
A YES vote supports necessary investments in important domestic and security priorities, and rejects the Republican budget's deep cut below the pre-sequester Budget Control Act Caps to fiscal year 2016 defense and non-defense discretionary funding. A NO vote continues the Republican strategy of gutting investments that are critical for economic growth and job creation, and misusing the war funding designation to pay for needed defense funding.
Preventing the End of Medicare as We Know It
(Lead Sponsor: Rep. Lujan-Grisham)
This amendment opposes changes that would eliminate guaranteed health insurance benefits for seniors and people with disabilities under the Medicare program, increase costs for seniors and people with disabilities by establishing a Medicare voucher or premium support plan that provides limited payments to Medicare beneficiaries to purchase health care in the private health insurance market, or weaken the traditional Medicare program by diverting the healthiest enrollees into private plans and undermining the program's ability to control costs while offering access to a broad range of providers. The Republican budget calls for transforming Medicare into a premium support or voucher program that would dramatically increase premiums for seniors who wish to use traditional Medicare.
A YES vote protects the Medicare guarantee for senior citizens and persons with disabilities who rely on Medicare. A NO vote jeopardizes health care coverage for these populations by refusing to prevent proposals that shift health care costs from the federal government to seniors and persons with disabilities by transforming Medicare into a voucher or premium support system.
Protect Medicaid for Children, Seniors, and People with Disabilities
(Lead Sponsor: Rep. Dingell)
This deficit-neutral amendment ensures that seniors, persons with disabilities, and children do not lose access to critical health care and long-term care services provided through Medicaid by rejecting the Republican budget's plan to block grant Medicaid and cut roughly $900 billion to the base Medicaid program. Medicaid improves health, access to health services, and financial security and is a vital safety net for hard-working families.
A YES vote protects health care and long-term care services for millions of seniors, persons with disabilities, and children. A NO vote undermines basic health care for vulnerable members of our society and hardworking American families.
Protect Tax Credits to Keep Health Coverage Affordable
(Lead Sponsor: Rep. Pascrell)
This deficit-neutral amendment restores the premium tax credits provided by the Affordable Care Act to ensure that middle class individuals and families and those striving to join the middle class can afford to purchase quality health care insurance plans that cover necessary health care goods and services, that protect patients from unlimited out-of-pocket costs that can lead to financial ruin, and that do not deny coverage or charge higher premiums based on pre-existing conditions.
A YES vote supports retaining the premium tax credits that are helping 8 million people buy quality, affordable health coverage this year and will help an estimated 15 million people do so in 2016. A NO vote rejects the Affordable Care Act tax credits that help make health coverage affordable and instead endorses taking away these tax credits starting next year.
Protect Nutrition Assistance
(Lead Sponsor: Rep. Moore)
This deficit-neutral amendment rejects the $125 billion in cuts to the Supplemental Nutrition Assistance Program (SNAP) included in the Republican budget. There is no way to achieve these savings without either pushing vulnerable people from the SNAP rolls or cutting SNAP benefits.
A YES vote will protect SNAP, helping millions of vulnerable Americans to maintain adequate diets. A NO vote means slashing SNAP funding, putting the nutritional needs of struggling families at risk.
National Strategy to Eradicate Poverty and Increase Opportunity
(Lead Sponsor: Rep. Lee)
This amendment supports a goal of developing a national strategy to eliminate poverty, with the initial goal of cutting poverty in half in ten years, and extending equitable access to economic opportunity to all Americans. It discusses a multi-pronged approach that allows workers to develop skills and have good jobs, removes barriers and obstacles to taking advantage of economic opportunities, and supports the most vulnerable in society. The amendment includes findings that make clear the important role that government plays in reducing poverty.
A YES vote supports development of a comprehensive national strategy to address poverty and lack of opportunity. A NO vote rejects both the findings that government programs play an important role in reducing poverty and the need to develop a national strategy to eradicate poverty and increase opportunity.
Protect Scientific Jobs and Provide a National Investment in Biomedical Research
(Lead Sponsor: Rep. Castor)
This deficit-neutral amendment provides mandatory funding to ensure resources for the National Institutes of Health (NIH) grow with our nation's economy over the next ten years. NIH conducts cutting-edge research and supports scientific jobs, and yet, over the last decade, growth in NIH's budget has not kept pace with inflation, leading to a decline in its purchasing power.
A YES vote ensures funding to maintain NIH's ability to advance cutting edge research and support young scientists. A NO vote jeopardizes technical jobs and lifesaving research.
Protect Access to Primary Care in Medicaid and Medicare
(Lead Sponsor: Rep. McDermott)
This deficit-neutral amendment protects access to primary care for Medicaid enrollees by providing funding for states to restore primary care reimbursement rates for physicians at 100 percent of the Medicare rate, and by extending these increased rates to additional providers. It also assumes a permanent 10 percent increase in Medicare rates for primary care in a budget-neutral manner.
A YES vote expands access to primary care for the millions of seniors, people with disabilities, and hardworking families who rely on Medicaid and Medicare. A NO vote undermines access to primary care and risks the health and well-being of Medicaid and Medicare enrollees.
Fully Fund VA Programs and Protect them from Future Government Shutdowns
(Lead Sponsor: Rep. Moulton)
This deficit-neutral amendment restores $6.3 billion in cuts below the President's request for veterans' programs for 2016 and 2017 to ensure veterans receive timely access to health care and benefits. It also extends advance appropriations to all discretionary programs at the Department of Veterans Affairs (VA) to help ensure funding is in place at the beginning of each fiscal year and to protect veterans' programs from future government shutdowns. The amendment also supports requiring the VA to submit along with its annual budget a "Future-Years Veterans Program." This will facilitate transparency and oversight with regard to VA's longer term plans and it will help Congress in enacting adequate advance appropriations.
A YES vote ensures veterans receive the benefits they have earned in a timely fashion and protects veterans' programs from a government shutdown. A NO vote means providing insufficient resources to ensure timely provision of benefits and services, and leaves those programs vulnerable to government shutdowns.
Adopt Comprehensive Immigration Reform
(Lead Sponsor: Rep. Yarmuth)
This amendment changes the budget to accommodate passage of comprehensive immigration reform, such as the Border Security, Economic Opportunity, and Immigration Modernization Act proposed by House Democrats during the 113th Congress, which will boost our economy, lower deficits, secure our borders, and establish clear and just rules for citizenship.
A YES vote boosts our economy, lowers our deficits, extends the Solvency of Social Security, helps secure our borders, and establishes clear and just rules for citizenship. A NO vote means a less robust economy, higher deficits, a less secure border, and an immigration system that will continue to keep millions of hard-working, law-abiding families who have lived in our communities for decades hiding in the shadows.
Accelerating Growth in U.S. Manufacturing
(Lead Sponsor: Rep. Ryan)
This deficit-neutral amendment strengthens U.S. manufacturing by establishing a Scale-Up Manufacturing Initiative and expanding the National Network of Manufacturing Institutes. The amendment advances our country's manufacturing technologies and ensures our nation's ideas and inventions are developed and produced in the United States.
A YES vote accelerates growth in U.S. manufacturing – an economic sector that employs millions of Americans. A NO vote fails to invest in ideas and technologies that create well-paying American jobs.
Protect Consumers from Abusive Financial Practices
(Lead Sponsor: Rep. Lieu)
This amendment expresses the House's support of continuing the Consumer Financial Protection Bureau's important work and funding mechanism that helps ensure its independence.
A YES vote supports the continued independence and efforts of the Bureau, whose efforts have won more than $5.3 billion in refunds and relief for 15 million consumers. A NO vote seeks to undermine the Bureau's work by exposing it to budget cuts and restrictions on its activities in the appropriations process.
Protect Help with Prescription Drug Costs and Other Valuable Medicare Benefits for Seniors
This amendment rejects the Republican budget's cuts to health care for current seniors and those near retirement. It expresses the sense of the House that the important new health benefits for seniors and disabled individuals provided in the Affordable Care Act (ACA) should be retained, rather than repealed as called for in the Republican budget. These benefits include the gradual closing of the Medicare prescription drug coverage gap, coverage of key preventive services with no co-pays or deductibles, and expanded support for alternatives to nursing homes.
A YES vote supports important ACA benefits for people with Medicare, including prescription drug cost relief and no co-pays or deductibles for life-saving preventive services. A NO vote increases costs for seniors in the "doughnut hole" – the Medicare prescription drug coverage gap – and increases costs to seniors for preventive health care services.
Protect Social Security Benefits from Cuts
This amendment expresses opposition to cutting Social Security benefits and support for Social Security's continued payment of Disability Insurance benefits using its $2.8 trillion in existing reserves.
A YES vote supports allowing the Social Security Administration to use its existing reserves to ensure that all earned benefits continue to be paid on time. A NO vote leaves the prospect of cuts in Social Security benefits on the table, particularly for Social Security Disability beneficiaries.
Invest in America's Transportation Infrastructure
This deficit-neutral amendment rejects the Republican budget's cuts in transportation spending, and puts Americans to work by increasing the investment in our nation's transportation infrastructure to address the immediate needs of our roads, bridges, and transit systems that are in disrepair. At a time when so many Americans are ready to work, it makes no sense to defer these investments when roads and bridges are falling apart, and to forgo the economic opportunities that would have been created in the interim.
A YES vote rejects the $187 billion cut in transportation spending that the Republican budget makes over ten years. A NO vote supports cutting the highway program and other transportation spending by 19 percent.
Increase Effectiveness of the Earned Income Tax Credit
This deficit-neutral amendment increases the Earned Income Tax Credit (EITC) for childless workers, who are the only group that can currently be taxed into poverty. It also allows some additional workers, including some who are either currently too young or too old to benefit, to claim the EITC.
A YES vote ensures that low-income childless workers can more fully benefit from the anti-poverty and employment effects of the EITC. A NO vote denies that support, which liberal and conservative experts agree is one of the most effective anti-poverty efforts.
Lower Student Debt by Refinancing Student Loans and Protecting Pell Grants and Student Loan Benefits
This deficit-neutral amendment helps students lower their debt by accommodating legislation that lets them refinance federal student loans to the lowest available rate, and by rejecting the Republican budget's cuts to Pell grants and to existing student loan programs.
A YES vote lowers students' debt by allowing them to refinance their federal loans and protecting current grant aid and student loan rates and repayment options. A NO vote makes college less accessible and increases student debt, which already stands at more than $1.3 trillion and exceeds all credit card debt in this country.
Importance of Raising the Minimum Wage
This amendment adds language calling for passage of legislation to raise the minimum wage.
A YES vote is a vote in support of increasing the federal minimum wage, which has not risen since 2009 and is now lower than the minimum wage in most states. A NO vote is a vote to keep the minimum wage unchanged, denying a raise to millions of Americans and leaving many of them in poverty.
Promote Early Childhood Development
This deficit-neutral amendment funds the President's early childhood initiative, creating universal access to high-quality preschool, expanding services in at-risk communities during pregnancy and to parents with young children through voluntary home visits, and extending the Children's Health Insurance Program for four years.
A YES vote invests in early childhood, ensuring children a healthy start and school readiness. A NO vote jeopardizes health care for millions of children and the continuation of a successful program that has provided nearly 1.4 million home visits in at-risk communities.
Truth in Budgeting Regarding Affordable Care Act Savings and Expiring Tax Provisions
This amendment prevents House Republicans from counting certain savings in their budget while pursuing legislation that would eliminate those savings. It promotes transparency in budgeting in two ways. First, it prohibits the House from considering legislation to repeal the Affordable Care Act in its entirety if the House has approved a budget resolution that includes the Affordable Care Act's revenue increases and Medicare savings in its spending and revenue numbers. Second, if the House has approved a budget resolution that includes the revenues projected to occur after tax provisions expire under current law, this amendment prevents the House from considering legislation to extend those expiring tax provisions without paying for the extension.
A YES vote supports the principle that the revenue and spending numbers in a budget resolution should honestly and accurately reflect the policies described in that resolution as well as the policies that the House majority plans to consider this year. A NO vote rejects the principle that the spending and revenue numbers in a budget should be accurate and consistent with the policies that resolution purports to include as well as the policies that the House majority actually intends to vote on.
This amendment provides additional oversight to prevent the use of the "Overseas Contingency Operations" designation to circumvent discretionary funding caps. Both the Pentagon and Congress have abused this loophole to fund non-war related activities. If discretionary caps are too low and additional funding is needed to address the country's priorities, Congress should amend the law to raise the caps rather than providing funding through backdoor loopholes that undermine the integrity of the budget process.
A YES vote maintains transparency and discipline in the budget process and prevents abuse of backdoor loopholes to circumvent spending caps. A NO vote means less transparency and less budget discipline and gives a green light to the use of backdoor loopholes to skirt spending caps.
Eliminate Overseas Contingency Operations Funding
This amendment puts a stop to the Republican attempt to undermine the budget process by eliminating the budget's extra $36 billion in Overseas Contingency Operations (OCO) funding. The amendment brings OCO levels back to those the President requested and what our military commanders and our diplomatic corps say are needed for 2016. It dedicates these savings toward deficit reduction.
A YES vote reduces the deficit by $36 billion and instills more discipline and transparency in the budget process. A NO vote increases the deficit and allows the OCO to continue to be used as a backdoor loophole to skirt discretionary funding caps.
Improving the Availability of Long-Term Care Services and Supports for Seniors and Other Americans
This amendment endorses initiatives to improve the availability of long-term care services and insurance for seniors and other Americans. Such initiatives could include creation of a comprehensive long-term care insurance program, pilot programs or studies to determine the best options for improving access to long-term care services, or improvements to Medicare, Medicaid, or other programs to provide increased access to long-term care. An estimated 7 in 10 Americans aged 65 or older will need long-term services and supports at some point. As the share of the U.S. population aged 65 and older continues to grow, the demand for long-term care services and supports will increase. Existing programs leave significant gaps in access to affordable care, and these gaps will get worse as the population ages.
A YES vote supports Congress taking action to improve access to affordable long-term care services. A NO vote rejects the idea that the Congress should take action to make sure that senior citizens and persons with disabilities can get long-term care services when they need them.
Supporting Infrastructure Investment
This amendment expresses Congress's support for investment in highways and a wide range of other infrastructure priorities.
A YES vote supports infrastructure investments that fuel future economic growth and jobs in the U.S. A NO vote opposes these critical investments
Preparing Students for 21st Century Jobs
This deficit-neutral amendment funds career and technical education that will prepare students to meet the demands of the 21st century workforce.
A YES vote helps ensure that every student graduates from high school ready for college and a career. A NO vote leaves funding for career and technical education below the 2012 level, despite the need to ensure students are prepared for college or careers in high-skill, high-demand jobs.
FY16 Republican Budget


*Both offices are closed on Saturday, Sunday and holidays. All of our phone calls from our Tulsa office are forwarded to the Wichita office Monday – Wednesday. Voicemail is checked periodically on the weekends.


The Elephant Conservation Center (ECC) focuses specifically on ecotourism and providing pregnant or lactating cows with a safe environment to give birth and wean their calves, while supporting an income for their owners through soft tourism.
At the beggining, the ECC also supported a specialised elephant hospital and laboratory, capable of detailed blood analysis and provision of full-time care for two sick or injured elephants simultaneously.
The Elephant Conservation Center differentiates itself from elephant tourist camps by being a haven for elephant reproduction, lactation, recovery and disease diagnosis.
Of the elephants residing at the ECC, most originate from the Sayaboury region and have worked in the logging industry. Rescued from this debilitating and dangerous work, these elephants will become ambassadors for the survival of their species as they recuperate and become more receptive to breeding.
The Elephant Conservation Center is a privately run company which has worked in partnership with French-based non-profit organisation ElefantAsia from 2011 to the end of 2015.


* Log-in access to this site, [mailto:ewedevteam@gmail.com?subject=Need%20wiki%20username contact us] if you require this.
* Use the following URL to access the Subversion repository: http://sources.ecopath.org/svn/Ecopath/trunk/Ecopath6.
* Use the following URL to access the Subversion repository: !http://sources.ecopath.org/svn/Ecopath/trunk/Ecopath6.


text:
package roaring

import (
	"bytes"
	"encoding/base64"
	"fmt"
	"io"
	"strconv"

	"github.com/RoaringBitmap/roaring/internal"
)

// Bitmap represents a compressed bitmap where you can add integers.
type Bitmap struct {
	highlowcontainer roaringArray
}

// ToBase64 serializes a bitmap as Base64
func (rb *Bitmap) ToBase64() (string, error) {
	buf := new(bytes.Buffer)
	_, err := rb.WriteTo(buf)
	return base64.StdEncoding.EncodeToString(buf.Bytes()), err

}

// FromBase64 deserializes a bitmap from Base64
func (rb *Bitmap) FromBase64(str string) (int64, error) {
	data, err := base64.StdEncoding.DecodeString(str)
	if err != nil {
		return 0, err
	}
	buf := bytes.NewBuffer(data)

	return rb.ReadFrom(buf)
}

// WriteTo writes a serialized version of this bitmap to stream.
// The format is compatible with other RoaringBitmap
// implementations (Java, C) and is documented here:
// https://github.com/RoaringBitmap/RoaringFormatSpec
func (rb *Bitmap) WriteTo(stream io.Writer) (int64, error) {
	return rb.highlowcontainer.writeTo(stream)
}

// ToBytes returns an array of bytes corresponding to what is written
// when calling WriteTo
func (rb *Bitmap) ToBytes() ([]byte, error) {
	return rb.highlowcontainer.toBytes()
}

// ReadFrom reads a serialized version of this bitmap from stream.
// The format is compatible with other RoaringBitmap
// implementations (Java, C) and is documented here:
// https://github.com/RoaringBitmap/RoaringFormatSpec
// Since io.Reader is regarded as a stream and cannot be read twice.
// So add cookieHeader to accept the 4-byte data that has been read in roaring64.ReadFrom.
// It is not necessary to pass cookieHeader when call roaring.ReadFrom to read the roaring32 data directly.
func (rb *Bitmap) ReadFrom(reader io.Reader, cookieHeader ...byte) (p int64, err error) {
	stream := internal.ByteInputAdapterPool.Get().(*internal.ByteInputAdapter)
	stream.Reset(reader)

	p, err = rb.highlowcontainer.readFrom(stream, cookieHeader...)
	internal.ByteInputAdapterPool.Put(stream)

	return
}

// FromBuffer creates a bitmap from its serialized version stored in buffer
//
// The format specification is available here:
// https://github.com/RoaringBitmap/RoaringFormatSpec
//
// The provided byte array (buf) is expected to be a constant.
// The function makes the best effort attempt not to copy data.
// You should take care not to modify buff as it will
// likely result in unexpected program behavior.
//
// Resulting bitmaps are effectively immutable in the following sense:
// a copy-on-write marker is used so that when you modify the resulting
// bitmap, copies of selected data (containers) are made.
// You should *not* change the copy-on-write status of the resulting
// bitmaps (SetCopyOnWrite).
//
// If buf becomes unavailable, then a bitmap created with
// FromBuffer would be effectively broken. Furthermore, any
// bitmap derived from this bitmap (e.g., via Or, And) might
// also be broken. Thus, before making buf unavailable, you should
// call CloneCopyOnWriteContainers on all such bitmaps.
//
func (rb *Bitmap) FromBuffer(buf []byte) (p int64, err error) {
	stream := internal.ByteBufferPool.Get().(*internal.ByteBuffer)
	stream.Reset(buf)

	p, err = rb.highlowcontainer.readFrom(stream)
	internal.ByteBufferPool.Put(stream)

	return
}

// RunOptimize attempts to further compress the runs of consecutive values found in the bitmap
func (rb *Bitmap) RunOptimize() {
	rb.highlowcontainer.runOptimize()
}

// HasRunCompression returns true if the bitmap benefits from run compression
func (rb *Bitmap) HasRunCompression() bool {
	return rb.highlowcontainer.hasRunCompression()
}

// MarshalBinary implements the encoding.BinaryMarshaler interface for the bitmap
// (same as ToBytes)
func (rb *Bitmap) MarshalBinary() ([]byte, error) {
	return rb.ToBytes()
}

// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface for the bitmap
func (rb *Bitmap) UnmarshalBinary(data []byte) error {
	r := bytes.NewReader(data)
	_, err := rb.ReadFrom(r)
	return err
}

// NewBitmap creates a new empty Bitmap (see also New)
func NewBitmap() *Bitmap {
	return &Bitmap{}
}

// New creates a new empty Bitmap (same as NewBitmap)
func New() *Bitmap {
	return &Bitmap{}
}

// Clear resets the Bitmap to be logically empty, but may retain
// some memory allocations that may speed up future operations
func (rb *Bitmap) Clear() {
	rb.highlowcontainer.clear()
}

// ToArray creates a new slice containing all of the integers stored in the Bitmap in sorted order
func (rb *Bitmap) ToArray() []uint32 {
	array := make([]uint32, rb.GetCardinality())
	pos := 0
	pos2 := 0

	for pos < rb.highlowcontainer.size() {
		hs := uint32(rb.highlowcontainer.getKeyAtIndex(pos)) << 16
		c := rb.highlowcontainer.getContainerAtIndex(pos)
		pos++
		pos2 = c.fillLeastSignificant16bits(array, pos2, hs)
	}
	return array
}

// GetSizeInBytes estimates the memory usage of the Bitmap. Note that this
// might differ slightly from the amount of bytes required for persistent storage
func (rb *Bitmap) GetSizeInBytes() uint64 {
	size := uint64(8)
	for _, c := range rb.highlowcontainer.containers {
		size += uint64(2) + uint64(c.getSizeInBytes())
	}
	return size
}

// GetSerializedSizeInBytes computes the serialized size in bytes
// of the Bitmap. It should correspond to the
// number of bytes written when invoking WriteTo. You can expect
// that this function is much cheaper computationally than WriteTo.
func (rb *Bitmap) GetSerializedSizeInBytes() uint64 {
	return rb.highlowcontainer.serializedSizeInBytes()
}

// BoundSerializedSizeInBytes returns an upper bound on the serialized size in bytes
// assuming that one wants to store "cardinality" integers in [0, universe_size)
func BoundSerializedSizeInBytes(cardinality uint64, universeSize uint64) uint64 {
	contnbr := (universeSize + uint64(65535)) / uint64(65536)
	if contnbr > cardinality {
		contnbr = cardinality
		// we can't have more containers than we have values
	}
	headermax := 8*contnbr + 4
	if 4 > (contnbr+7)/8 {
		headermax += 4
	} else {
		headermax += (contnbr + 7) / 8
	}
	valsarray := uint64(arrayContainerSizeInBytes(int(cardinality)))
	valsbitmap := contnbr * uint64(bitmapContainerSizeInBytes())
	valsbest := valsarray
	if valsbest > valsbitmap {
		valsbest = valsbitmap
	}
	return valsbest + headermax
}

// IntIterable allows you to iterate over the values in a Bitmap
type IntIterable interface {
	HasNext() bool
	Next() uint32
}

// IntPeekable allows you to look at the next value without advancing and
// advance as long as the next value is smaller than minval
type IntPeekable interface {
	IntIterable
	// PeekNext peeks the next value without advancing the iterator
	PeekNext() uint32
	// AdvanceIfNeeded advances as long as the next value is smaller than minval
	AdvanceIfNeeded(minval uint32)
}

type intIterator struct {
	pos              int
	hs               uint32
	iter             shortPeekable
	highlowcontainer *roaringArray
}

// HasNext returns true if there are more integers to iterate over
func (ii *intIterator) HasNext() bool {
	return ii.pos < ii.highlowcontainer.size()
}

func (ii *intIterator) init() {
	if ii.highlowcontainer.size() > ii.pos {
		ii.iter = ii.highlowcontainer.getContainerAtIndex(ii.pos).getShortIterator()
		ii.hs = uint32(ii.highlowcontainer.getKeyAtIndex(ii.pos)) << 16
	}
}

// Next returns the next integer
func (ii *intIterator) Next() uint32 {
	x := uint32(ii.iter.next()) | ii.hs
	if !ii.iter.hasNext() {
		ii.pos = ii.pos + 1
		ii.init()
	}
	return x
}

// PeekNext peeks the next value without advancing the iterator
func (ii *intIterator) PeekNext() uint32 {
	return uint32(ii.iter.peekNext()&maxLowBit) | ii.hs
}

// AdvanceIfNeeded advances as long as the next value is smaller than minval
func (ii *intIterator) AdvanceIfNeeded(minval uint32) {
	to := minval >> 16

	for ii.HasNext() && (ii.hs>>16) < to {
		ii.pos++
		ii.init()
	}

	if ii.HasNext() && (ii.hs>>16) == to {
		ii.iter.advanceIfNeeded(lowbits(minval))

		if !ii.iter.hasNext() {
			ii.pos++
			ii.init()
		}
	}
}

func newIntIterator(a *Bitmap) *intIterator {
	p := new(intIterator)
	p.pos = 0
	p.highlowcontainer = &a.highlowcontainer
	p.init()
	return p
}

type intReverseIterator struct {
	pos              int
	hs               uint32
	iter             shortIterable
	highlowcontainer *roaringArray
}

// HasNext returns true if there are more integers to iterate over
func (ii *intReverseIterator) HasNext() bool {
	return ii.pos >= 0
}

func (ii *intReverseIterator) init() {
	if ii.pos >= 0 {
		ii.iter = ii.highlowcontainer.getContainerAtIndex(ii.pos).getReverseIterator()
		ii.hs = uint32(ii.highlowcontainer.getKeyAtIndex(ii.pos)) << 16
	} else {
		ii.iter = nil
	}
}

// Next returns the next integer
func (ii *intReverseIterator) Next() uint32 {
	x := uint32(ii.iter.next()) | ii.hs
	if !ii.iter.hasNext() {
		ii.pos = ii.pos - 1
		ii.init()
	}
	return x
}

func newIntReverseIterator(a *Bitmap) *intReverseIterator {
	p := new(intReverseIterator)
	p.highlowcontainer = &a.highlowcontainer
	p.pos = a.highlowcontainer.size() - 1
	p.init()
	return p
}

// ManyIntIterable allows you to iterate over the values in a Bitmap
type ManyIntIterable interface {
	// NextMany fills buf up with values, returns how many values were returned
	NextMany(buf []uint32) int
	// NextMany64 fills up buf with 64 bit values, uses hs as a mask (OR), returns how many values were returned
	NextMany64(hs uint64, buf []uint64) int
}

type manyIntIterator struct {
	pos              int
	hs               uint32
	iter             manyIterable
	highlowcontainer *roaringArray
}

func (ii *manyIntIterator) init() {
	if ii.highlowcontainer.size() > ii.pos {
		ii.iter = ii.highlowcontainer.getContainerAtIndex(ii.pos).getManyIterator()
		ii.hs = uint32(ii.highlowcontainer.getKeyAtIndex(ii.pos)) << 16
	} else {
		ii.iter = nil
	}
}

func (ii *manyIntIterator) NextMany(buf []uint32) int {
	n := 0
	for n < len(buf) {
		if ii.iter == nil {
			break
		}
		moreN := ii.iter.nextMany(ii.hs, buf[n:])
		n += moreN
		if moreN == 0 {
			ii.pos = ii.pos + 1
			ii.init()
		}
	}

	return n
}

func (ii *manyIntIterator) NextMany64(hs64 uint64, buf []uint64) int {
	n := 0
	for n < len(buf) {
		if ii.iter == nil {
			break
		}

		hs := uint64(ii.hs) | hs64
		moreN := ii.iter.nextMany64(hs, buf[n:])
		n += moreN
		if moreN == 0 {
			ii.pos = ii.pos + 1
			ii.init()
		}
	}

	return n
}

func newManyIntIterator(a *Bitmap) *manyIntIterator {
	p := new(manyIntIterator)
	p.pos = 0
	p.highlowcontainer = &a.highlowcontainer
	p.init()
	return p
}

// String creates a string representation of the Bitmap
func (rb *Bitmap) String() string {
	// inspired by https://github.com/fzandona/goroar/
	var buffer bytes.Buffer
	start := []byte("{")
	buffer.Write(start)
	i := rb.Iterator()
	counter := 0
	if i.HasNext() {
		counter = counter + 1
		buffer.WriteString(strconv.FormatInt(int64(i.Next()), 10))
	}
	for i.HasNext() {
		buffer.WriteString(",")
		counter = counter + 1
		// to avoid exhausting the memory
		if counter > 0x40000 {
			buffer.WriteString("...")
			break
		}
		buffer.WriteString(strconv.FormatInt(int64(i.Next()), 10))
	}
	buffer.WriteString("}")
	return buffer.String()
}

// Iterate iterates over the bitmap, calling the given callback with each value in the bitmap.  If the callback returns
// false, the iteration is halted.
// The iteration results are undefined if the bitmap is modified (e.g., with Add or Remove).
// There is no guarantee as to what order the values will be iterated
func (rb *Bitmap) Iterate(cb func(x uint32) bool) {
	for i := 0; i < rb.highlowcontainer.size(); i++ {
		hs := uint32(rb.highlowcontainer.getKeyAtIndex(i)) << 16
		c := rb.highlowcontainer.getContainerAtIndex(i)

		var shouldContinue bool
		// This is hacky but it avoids allocations from invoking an interface method with a closure
		switch t := c.(type) {
		case *arrayContainer:
			shouldContinue = t.iterate(func(x uint16) bool {
				return cb(uint32(x) | hs)
			})
		case *runContainer16:
			shouldContinue = t.iterate(func(x uint16) bool {
				return cb(uint32(x) | hs)
			})
		case *bitmapContainer:
			shouldContinue = t.iterate(func(x uint16) bool {
				return cb(uint32(x) | hs)
			})
		}

		if !shouldContinue {
			break
		}
	}
}

// Iterator creates a new IntPeekable to iterate over the integers contained in the bitmap, in sorted order;
// the iterator becomes invalid if the bitmap is modified (e.g., with Add or Remove).
func (rb *Bitmap) Iterator() IntPeekable {
	return newIntIterator(rb)
}

// ReverseIterator creates a new IntIterable to iterate over the integers contained in the bitmap, in sorted order;
// the iterator becomes invalid if the bitmap is modified (e.g., with Add or Remove).
func (rb *Bitmap) ReverseIterator() IntIterable {
	return newIntReverseIterator(rb)
}

// ManyIterator creates a new ManyIntIterable to iterate over the integers contained in the bitmap, in sorted order;
// the iterator becomes invalid if the bitmap is modified (e.g., with Add or Remove).
func (rb *Bitmap) ManyIterator() ManyIntIterable {
	return newManyIntIterator(rb)
}

// Clone creates a copy of the Bitmap
func (rb *Bitmap) Clone() *Bitmap {
	ptr := new(Bitmap)
	ptr.highlowcontainer = *rb.highlowcontainer.clone()
	return ptr
}

// Minimum get the smallest value stored in this roaring bitmap, assumes that it is not empty
func (rb *Bitmap) Minimum() uint32 {
	return uint32(rb.highlowcontainer.containers[0].minimum()) | (uint32(rb.highlowcontainer.keys[0]) << 16)
}

// Maximum get the largest value stored in this roaring bitmap, assumes that it is not empty
func (rb *Bitmap) Maximum() uint32 {
	lastindex := len(rb.highlowcontainer.containers) - 1
	return uint32(rb.highlowcontainer.containers[lastindex].maximum()) | (uint32(rb.highlowcontainer.keys[lastindex]) << 16)
}

// Contains returns true if the integer is contained in the bitmap
func (rb *Bitmap) Contains(x uint32) bool {
	hb := highbits(x)
	c := rb.highlowcontainer.getContainer(hb)
	return c != nil && c.contains(lowbits(x))
}

// ContainsInt returns true if the integer is contained in the bitmap (this is a convenience method, the parameter is casted to uint32 and Contains is called)
func (rb *Bitmap) ContainsInt(x int) bool {
	return rb.Contains(uint32(x))
}

// Equals returns true if the two bitmaps contain the same integers
func (rb *Bitmap) Equals(o interface{}) bool {
	srb, ok := o.(*Bitmap)
	if ok {
		return srb.highlowcontainer.equals(rb.highlowcontainer)
	}
	return false
}

// AddOffset adds the value 'offset' to each and every value in a bitmap, generating a new bitmap in the process
func AddOffset(x *Bitmap, offset uint32) (answer *Bitmap) {
	return AddOffset64(x, int64(offset))
}

// AddOffset64 adds the value 'offset' to each and every value in a bitmap, generating a new bitmap in the process
// If offset + element is outside of the range [0,2^32), that the element will be dropped
func AddOffset64(x *Bitmap, offset int64) (answer *Bitmap) {
	// we need "offset" to be a long because we want to support values
	// between -0xFFFFFFFF up to +-0xFFFFFFFF
	var containerOffset64 int64

	if offset < 0 {
		containerOffset64 = (offset - (1 << 16) + 1) / (1 << 16)
	} else {
		containerOffset64 = offset >> 16
	}

	if containerOffset64 >= (1<<16) || containerOffset64 <= -(1<<16) {
		return New()
	}

	containerOffset := int32(containerOffset64)
	inOffset := (uint16)(offset - containerOffset64*(1<<16))

	if inOffset == 0 {
		answer = x.Clone()
		for pos := 0; pos < answer.highlowcontainer.size(); pos++ {
			key := int32(answer.highlowcontainer.getKeyAtIndex(pos))
			key += containerOffset

			if key >= 0 && key <= MaxUint16 {
				answer.highlowcontainer.keys[pos] = uint16(key)
			}
		}
	} else {
		answer = New()

		for pos := 0; pos < x.highlowcontainer.size(); pos++ {
			key := int32(x.highlowcontainer.getKeyAtIndex(pos))
			key += containerOffset

			c := x.highlowcontainer.getContainerAtIndex(pos)
			offsetted := c.addOffset(inOffset)

			if !offsetted[0].isEmpty() && (key >= 0 && key <= MaxUint16) {
				curSize := answer.highlowcontainer.size()
				lastkey := int32(0)

				if curSize > 0 {
					lastkey = int32(answer.highlowcontainer.getKeyAtIndex(curSize - 1))
				}

				if curSize > 0 && lastkey == key {
					prev := answer.highlowcontainer.getContainerAtIndex(curSize - 1)
					orrseult := prev.ior(offsetted[0])
					answer.highlowcontainer.setContainerAtIndex(curSize-1, orrseult)
				} else {
					answer.highlowcontainer.appendContainer(uint16(key), offsetted[0], false)
				}
			}

			if !offsetted[1].isEmpty() && ((key+1) >= 0 && (key+1) <= MaxUint16) {
				answer.highlowcontainer.appendContainer(uint16(key+1), offsetted[1], false)
			}
		}
	}

	return answer
}

// Add the integer x to the bitmap
func (rb *Bitmap) Add(x uint32) {
	hb := highbits(x)
	ra := &rb.highlowcontainer
	i := ra.getIndex(hb)
	if i >= 0 {
		var c container
		c = ra.getWritableContainerAtIndex(i).iaddReturnMinimized(lowbits(x))
		rb.highlowcontainer.setContainerAtIndex(i, c)
	} else {
		newac := newArrayContainer()
		rb.highlowcontainer.insertNewKeyValueAt(-i-1, hb, newac.iaddReturnMinimized(lowbits(x)))
	}
}

// add the integer x to the bitmap, return the container and its index
func (rb *Bitmap) addwithptr(x uint32) (int, container) {
	hb := highbits(x)
	ra := &rb.highlowcontainer
	i := ra.getIndex(hb)
	var c container
	if i >= 0 {
		c = ra.getWritableContainerAtIndex(i).iaddReturnMinimized(lowbits(x))
		rb.highlowcontainer.setContainerAtIndex(i, c)
		return i, c
	}
	newac := newArrayContainer()
	c = newac.iaddReturnMinimized(lowbits(x))
	rb.highlowcontainer.insertNewKeyValueAt(-i-1, hb, c)
	return -i - 1, c
}

// CheckedAdd adds the integer x to the bitmap and return true  if it was added (false if the integer was already present)
func (rb *Bitmap) CheckedAdd(x uint32) bool {
	// TODO: add unit tests for this method
	hb := highbits(x)
	i := rb.highlowcontainer.getIndex(hb)
	if i >= 0 {
		C := rb.highlowcontainer.getWritableContainerAtIndex(i)
		oldcard := C.getCardinality()
		C = C.iaddReturnMinimized(lowbits(x))
		rb.highlowcontainer.setContainerAtIndex(i, C)
		return C.getCardinality() > oldcard
	}
	newac := newArrayContainer()
	rb.highlowcontainer.insertNewKeyValueAt(-i-1, hb, newac.iaddReturnMinimized(lowbits(x)))
	return true

}

// AddInt adds the integer x to the bitmap (convenience method: the parameter is casted to uint32 and we call Add)
func (rb *Bitmap) AddInt(x int) {
	rb.Add(uint32(x))
}

// Remove the integer x from the bitmap
func (rb *Bitmap) Remove(x uint32) {
	hb := highbits(x)
	i := rb.highlowcontainer.getIndex(hb)
	if i >= 0 {
		c := rb.highlowcontainer.getWritableContainerAtIndex(i).iremoveReturnMinimized(lowbits(x))
		rb.highlowcontainer.setContainerAtIndex(i, c)
		if rb.highlowcontainer.getContainerAtIndex(i).isEmpty() {
			rb.highlowcontainer.removeAtIndex(i)
		}
	}
}

// CheckedRemove removes the integer x from the bitmap and return true if the integer was effectively removed (and false if the integer was not present)
func (rb *Bitmap) CheckedRemove(x uint32) bool {
	// TODO: add unit tests for this method
	hb := highbits(x)
	i := rb.highlowcontainer.getIndex(hb)
	if i >= 0 {
		C := rb.highlowcontainer.getWritableContainerAtIndex(i)
		oldcard := C.getCardinality()
		C = C.iremoveReturnMinimized(lowbits(x))
		rb.highlowcontainer.setContainerAtIndex(i, C)
		if rb.highlowcontainer.getContainerAtIndex(i).isEmpty() {
			rb.highlowcontainer.removeAtIndex(i)
			return true
		}
		return C.getCardinality() < oldcard
	}
	return false

}

// IsEmpty returns true if the Bitmap is empty (it is faster than doing (GetCardinality() == 0))
func (rb *Bitmap) IsEmpty() bool {
	return rb.highlowcontainer.size() == 0
}

// GetCardinality returns the number of integers contained in the bitmap
func (rb *Bitmap) GetCardinality() uint64 {
	size := uint64(0)
	for _, c := range rb.highlowcontainer.containers {
		size += uint64(c.getCardinality())
	}
	return size
}

// Rank returns the number of integers that are smaller or equal to x (Rank(infinity) would be GetCardinality()).
// If you pass the smallest value, you get the value 1. If you pass a value that is smaller than the smallest
// value, you get 0. Note that this function differs in convention from the Select function since it
// return 1 and not 0 on the smallest value.
func (rb *Bitmap) Rank(x uint32) uint64 {
	size := uint64(0)
	for i := 0; i < rb.highlowcontainer.size(); i++ {
		key := rb.highlowcontainer.getKeyAtIndex(i)
		if key > highbits(x) {
			return size
		}
		if key < highbits(x) {
			size += uint64(rb.highlowcontainer.getContainerAtIndex(i).getCardinality())
		} else {
			return size + uint64(rb.highlowcontainer.getContainerAtIndex(i).rank(lowbits(x)))
		}
	}
	return size
}

// Select returns the xth integer in the bitmap. If you pass 0, you get
// the smallest element. Note that this function differs in convention from
// the Rank function which returns 1 on the smallest value.
func (rb *Bitmap) Select(x uint32) (uint32, error) {
	if rb.GetCardinality() <= uint64(x) {
		return 0, fmt.Errorf("can't find %dth integer in a bitmap with only %d items", x, rb.GetCardinality())
	}

	remaining := x
	for i := 0; i < rb.highlowcontainer.size(); i++ {
		c := rb.highlowcontainer.getContainerAtIndex(i)
		card := uint32(c.getCardinality())
		if remaining >= card {
			remaining -= card
		} else {
			key := rb.highlowcontainer.getKeyAtIndex(i)
			return uint32(key)<<16 + uint32(c.selectInt(uint16(remaining))), nil
		}
	}
	return 0, fmt.Errorf("can't find %dth integer in a bitmap with only %d items", x, rb.GetCardinality())
}

// And computes the intersection between two bitmaps and stores the result in the current bitmap
func (rb *Bitmap) And(x2 *Bitmap) {
	pos1 := 0
	pos2 := 0
	intersectionsize := 0
	length1 := rb.highlowcontainer.size()
	length2 := x2.highlowcontainer.size()

main:
	for {
		if pos1 < length1 && pos2 < length2 {
			s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
			s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
			for {
				if s1 == s2 {
					c1 := rb.highlowcontainer.getWritableContainerAtIndex(pos1)
					c2 := x2.highlowcontainer.getContainerAtIndex(pos2)
					diff := c1.iand(c2)
					if !diff.isEmpty() {
						rb.highlowcontainer.replaceKeyAndContainerAtIndex(intersectionsize, s1, diff, false)
						intersectionsize++
					}
					pos1++
					pos2++
					if (pos1 == length1) || (pos2 == length2) {
						break main
					}
					s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
					s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
				} else if s1 < s2 {
					pos1 = rb.highlowcontainer.advanceUntil(s2, pos1)
					if pos1 == length1 {
						break main
					}
					s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
				} else { //s1 > s2
					pos2 = x2.highlowcontainer.advanceUntil(s1, pos2)
					if pos2 == length2 {
						break main
					}
					s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
				}
			}
		} else {
			break
		}
	}
	rb.highlowcontainer.resize(intersectionsize)
}

// OrCardinality  returns the cardinality of the union between two bitmaps, bitmaps are not modified
func (rb *Bitmap) OrCardinality(x2 *Bitmap) uint64 {
	pos1 := 0
	pos2 := 0
	length1 := rb.highlowcontainer.size()
	length2 := x2.highlowcontainer.size()
	answer := uint64(0)
main:
	for {
		if (pos1 < length1) && (pos2 < length2) {
			s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
			s2 := x2.highlowcontainer.getKeyAtIndex(pos2)

			for {
				if s1 < s2 {
					answer += uint64(rb.highlowcontainer.getContainerAtIndex(pos1).getCardinality())
					pos1++
					if pos1 == length1 {
						break main
					}
					s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
				} else if s1 > s2 {
					answer += uint64(x2.highlowcontainer.getContainerAtIndex(pos2).getCardinality())
					pos2++
					if pos2 == length2 {
						break main
					}
					s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
				} else {
					// TODO: could be faster if we did not have to materialize the container
					answer += uint64(rb.highlowcontainer.getContainerAtIndex(pos1).or(x2.highlowcontainer.getContainerAtIndex(pos2)).getCardinality())
					pos1++
					pos2++
					if (pos1 == length1) || (pos2 == length2) {
						break main
					}
					s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
					s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
				}
			}
		} else {
			break
		}
	}
	for ; pos1 < length1; pos1++ {
		answer += uint64(rb.highlowcontainer.getContainerAtIndex(pos1).getCardinality())
	}
	for ; pos2 < length2; pos2++ {
		answer += uint64(x2.highlowcontainer.getContainerAtIndex(pos2).getCardinality())
	}
	return answer
}

// AndCardinality returns the cardinality of the intersection between two bitmaps, bitmaps are not modified
func (rb *Bitmap) AndCardinality(x2 *Bitmap) uint64 {
	pos1 := 0
	pos2 := 0
	answer := uint64(0)
	length1 := rb.highlowcontainer.size()
	length2 := x2.highlowcontainer.size()

main:
	for {
		if pos1 < length1 && pos2 < length2 {
			s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
			s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
			for {
				if s1 == s2 {
					c1 := rb.highlowcontainer.getContainerAtIndex(pos1)
					c2 := x2.highlowcontainer.getContainerAtIndex(pos2)
					answer += uint64(c1.andCardinality(c2))
					pos1++
					pos2++
					if (pos1 == length1) || (pos2 == length2) {
						break main
					}
					s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
					s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
				} else if s1 < s2 {
					pos1 = rb.highlowcontainer.advanceUntil(s2, pos1)
					if pos1 == length1 {
						break main
					}
					s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
				} else { //s1 > s2
					pos2 = x2.highlowcontainer.advanceUntil(s1, pos2)
					if pos2 == length2 {
						break main
					}
					s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
				}
			}
		} else {
			break
		}
	}
	return answer
}

// Intersects checks whether two bitmap intersects, bitmaps are not modified
func (rb *Bitmap) Intersects(x2 *Bitmap) bool {
	pos1 := 0
	pos2 := 0
	length1 := rb.highlowcontainer.size()
	length2 := x2.highlowcontainer.size()

main:
	for {
		if pos1 < length1 && pos2 < length2 {
			s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
			s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
			for {
				if s1 == s2 {
					c1 := rb.highlowcontainer.getContainerAtIndex(pos1)
					c2 := x2.highlowcontainer.getContainerAtIndex(pos2)
					if c1.intersects(c2) {
						return true
					}
					pos1++
					pos2++
					if (pos1 == length1) || (pos2 == length2) {
						break main
					}
					s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
					s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
				} else if s1 < s2 {
					pos1 = rb.highlowcontainer.advanceUntil(s2, pos1)
					if pos1 == length1 {
						break main
					}
					s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
				} else { //s1 > s2
					pos2 = x2.highlowcontainer.advanceUntil(s1, pos2)
					if pos2 == length2 {
						break main
					}
					s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
				}
			}
		} else {
			break
		}
	}
	return false
}

// Xor computes the symmetric difference between two bitmaps and stores the result in the current bitmap
func (rb *Bitmap) Xor(x2 *Bitmap) {
	pos1 := 0
	pos2 := 0
	length1 := rb.highlowcontainer.size()
	length2 := x2.highlowcontainer.size()
	for {
		if (pos1 < length1) && (pos2 < length2) {
			s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
			s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
			if s1 < s2 {
				pos1 = rb.highlowcontainer.advanceUntil(s2, pos1)
				if pos1 == length1 {
					break
				}
			} else if s1 > s2 {
				c := x2.highlowcontainer.getWritableContainerAtIndex(pos2)
				rb.highlowcontainer.insertNewKeyValueAt(pos1, x2.highlowcontainer.getKeyAtIndex(pos2), c)
				length1++
				pos1++
				pos2++
			} else {
				// TODO: couple be computed in-place for reduced memory usage
				c := rb.highlowcontainer.getContainerAtIndex(pos1).xor(x2.highlowcontainer.getContainerAtIndex(pos2))
				if !c.isEmpty() {
					rb.highlowcontainer.setContainerAtIndex(pos1, c)
					pos1++
				} else {
					rb.highlowcontainer.removeAtIndex(pos1)
					length1--
				}
				pos2++
			}
		} else {
			break
		}
	}
	if pos1 == length1 {
		rb.highlowcontainer.appendCopyMany(x2.highlowcontainer, pos2, length2)
	}
}

// Or computes the union between two bitmaps and stores the result in the current bitmap
func (rb *Bitmap) Or(x2 *Bitmap) {
	pos1 := 0
	pos2 := 0
	length1 := rb.highlowcontainer.size()
	length2 := x2.highlowcontainer.size()
main:
	for (pos1 < length1) && (pos2 < length2) {
		s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
		s2 := x2.highlowcontainer.getKeyAtIndex(pos2)

		for {
			if s1 < s2 {
				pos1++
				if pos1 == length1 {
					break main
				}
				s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
			} else if s1 > s2 {
				rb.highlowcontainer.insertNewKeyValueAt(pos1, s2, x2.highlowcontainer.getContainerAtIndex(pos2).clone())
				pos1++
				length1++
				pos2++
				if pos2 == length2 {
					break main
				}
				s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
			} else {
				rb.highlowcontainer.replaceKeyAndContainerAtIndex(pos1, s1, rb.highlowcontainer.getUnionedWritableContainer(pos1, x2.highlowcontainer.getContainerAtIndex(pos2)), false)
				pos1++
				pos2++
				if (pos1 == length1) || (pos2 == length2) {
					break main
				}
				s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
				s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
			}
		}
	}
	if pos1 == length1 {
		rb.highlowcontainer.appendCopyMany(x2.highlowcontainer, pos2, length2)
	}
}

// AndNot computes the difference between two bitmaps and stores the result in the current bitmap
func (rb *Bitmap) AndNot(x2 *Bitmap) {
	pos1 := 0
	pos2 := 0
	intersectionsize := 0
	length1 := rb.highlowcontainer.size()
	length2 := x2.highlowcontainer.size()

main:
	for {
		if pos1 < length1 && pos2 < length2 {
			s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
			s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
			for {
				if s1 == s2 {
					c1 := rb.highlowcontainer.getWritableContainerAtIndex(pos1)
					c2 := x2.highlowcontainer.getContainerAtIndex(pos2)
					diff := c1.iandNot(c2)
					if !diff.isEmpty() {
						rb.highlowcontainer.replaceKeyAndContainerAtIndex(intersectionsize, s1, diff, false)
						intersectionsize++
					}
					pos1++
					pos2++
					if (pos1 == length1) || (pos2 == length2) {
						break main
					}
					s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
					s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
				} else if s1 < s2 {
					c1 := rb.highlowcontainer.getContainerAtIndex(pos1)
					mustCopyOnWrite := rb.highlowcontainer.needsCopyOnWrite(pos1)
					rb.highlowcontainer.replaceKeyAndContainerAtIndex(intersectionsize, s1, c1, mustCopyOnWrite)
					intersectionsize++
					pos1++
					if pos1 == length1 {
						break main
					}
					s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
				} else { //s1 > s2
					pos2 = x2.highlowcontainer.advanceUntil(s1, pos2)
					if pos2 == length2 {
						break main
					}
					s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
				}
			}
		} else {
			break
		}
	}
	// TODO:implement as a copy
	for pos1 < length1 {
		c1 := rb.highlowcontainer.getContainerAtIndex(pos1)
		s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
		mustCopyOnWrite := rb.highlowcontainer.needsCopyOnWrite(pos1)
		rb.highlowcontainer.replaceKeyAndContainerAtIndex(intersectionsize, s1, c1, mustCopyOnWrite)
		intersectionsize++
		pos1++
	}
	rb.highlowcontainer.resize(intersectionsize)
}

// Or computes the union between two bitmaps and returns the result
func Or(x1, x2 *Bitmap) *Bitmap {
	answer := NewBitmap()
	pos1 := 0
	pos2 := 0
	length1 := x1.highlowcontainer.size()
	length2 := x2.highlowcontainer.size()
main:
	for (pos1 < length1) && (pos2 < length2) {
		s1 := x1.highlowcontainer.getKeyAtIndex(pos1)
		s2 := x2.highlowcontainer.getKeyAtIndex(pos2)

		for {
			if s1 < s2 {
				answer.highlowcontainer.appendCopy(x1.highlowcontainer, pos1)
				pos1++
				if pos1 == length1 {
					break main
				}
				s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
			} else if s1 > s2 {
				answer.highlowcontainer.appendCopy(x2.highlowcontainer, pos2)
				pos2++
				if pos2 == length2 {
					break main
				}
				s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
			} else {

				answer.highlowcontainer.appendContainer(s1, x1.highlowcontainer.getContainerAtIndex(pos1).or(x2.highlowcontainer.getContainerAtIndex(pos2)), false)
				pos1++
				pos2++
				if (pos1 == length1) || (pos2 == length2) {
					break main
				}
				s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
				s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
			}
		}
	}
	if pos1 == length1 {
		answer.highlowcontainer.appendCopyMany(x2.highlowcontainer, pos2, length2)
	} else if pos2 == length2 {
		answer.highlowcontainer.appendCopyMany(x1.highlowcontainer, pos1, length1)
	}
	return answer
}

// And computes the intersection between two bitmaps and returns the result
func And(x1, x2 *Bitmap) *Bitmap {
	answer := NewBitmap()
	pos1 := 0
	pos2 := 0
	length1 := x1.highlowcontainer.size()
	length2 := x2.highlowcontainer.size()
main:
	for pos1 < length1 && pos2 < length2 {
		s1 := x1.highlowcontainer.getKeyAtIndex(pos1)
		s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
		for {
			if s1 == s2 {
				C := x1.highlowcontainer.getContainerAtIndex(pos1)
				C = C.and(x2.highlowcontainer.getContainerAtIndex(pos2))

				if !C.isEmpty() {
					answer.highlowcontainer.appendContainer(s1, C, false)
				}
				pos1++
				pos2++
				if (pos1 == length1) || (pos2 == length2) {
					break main
				}
				s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
				s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
			} else if s1 < s2 {
				pos1 = x1.highlowcontainer.advanceUntil(s2, pos1)
				if pos1 == length1 {
					break main
				}
				s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
			} else { // s1 > s2
				pos2 = x2.highlowcontainer.advanceUntil(s1, pos2)
				if pos2 == length2 {
					break main
				}
				s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
			}
		}
	}
	return answer
}

// Xor computes the symmetric difference between two bitmaps and returns the result
func Xor(x1, x2 *Bitmap) *Bitmap {
	answer := NewBitmap()
	pos1 := 0
	pos2 := 0
	length1 := x1.highlowcontainer.size()
	length2 := x2.highlowcontainer.size()
	for {
		if (pos1 < length1) && (pos2 < length2) {
			s1 := x1.highlowcontainer.getKeyAtIndex(pos1)
			s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
			if s1 < s2 {
				answer.highlowcontainer.appendCopy(x1.highlowcontainer, pos1)
				pos1++
			} else if s1 > s2 {
				answer.highlowcontainer.appendCopy(x2.highlowcontainer, pos2)
				pos2++
			} else {
				c := x1.highlowcontainer.getContainerAtIndex(pos1).xor(x2.highlowcontainer.getContainerAtIndex(pos2))
				if !c.isEmpty() {
					answer.highlowcontainer.appendContainer(s1, c, false)
				}
				pos1++
				pos2++
			}
		} else {
			break
		}
	}
	if pos1 == length1 {
		answer.highlowcontainer.appendCopyMany(x2.highlowcontainer, pos2, length2)
	} else if pos2 == length2 {
		answer.highlowcontainer.appendCopyMany(x1.highlowcontainer, pos1, length1)
	}
	return answer
}

// AndNot computes the difference between two bitmaps and returns the result
func AndNot(x1, x2 *Bitmap) *Bitmap {
	answer := NewBitmap()
	pos1 := 0
	pos2 := 0
	length1 := x1.highlowcontainer.size()
	length2 := x2.highlowcontainer.size()

main:
	for {
		if pos1 < length1 && pos2 < length2 {
			s1 := x1.highlowcontainer.getKeyAtIndex(pos1)
			s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
			for {
				if s1 < s2 {
					answer.highlowcontainer.appendCopy(x1.highlowcontainer, pos1)
					pos1++
					if pos1 == length1 {
						break main
					}
					s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
				} else if s1 == s2 {
					c1 := x1.highlowcontainer.getContainerAtIndex(pos1)
					c2 := x2.highlowcontainer.getContainerAtIndex(pos2)
					diff := c1.andNot(c2)
					if !diff.isEmpty() {
						answer.highlowcontainer.appendContainer(s1, diff, false)
					}
					pos1++
					pos2++
					if (pos1 == length1) || (pos2 == length2) {
						break main
					}
					s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
					s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
				} else { //s1 > s2
					pos2 = x2.highlowcontainer.advanceUntil(s1, pos2)
					if pos2 == length2 {
						break main
					}
					s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
				}
			}
		} else {
			break
		}
	}
	if pos2 == length2 {
		answer.highlowcontainer.appendCopyMany(x1.highlowcontainer, pos1, length1)
	}
	return answer
}

// AddMany add all of the values in dat
func (rb *Bitmap) AddMany(dat []uint32) {
	if len(dat) == 0 {
		return
	}
	prev := dat[0]
	idx, c := rb.addwithptr(prev)
	for _, i := range dat[1:] {
		if highbits(prev) == highbits(i) {
			c = c.iaddReturnMinimized(lowbits(i))
			rb.highlowcontainer.setContainerAtIndex(idx, c)
		} else {
			idx, c = rb.addwithptr(i)
		}
		prev = i
	}
}

// BitmapOf generates a new bitmap filled with the specified integers
func BitmapOf(dat ...uint32) *Bitmap {
	ans := NewBitmap()
	ans.AddMany(dat)
	return ans
}

// Flip negates the bits in the given range (i.e., [rangeStart,rangeEnd)), any integer present in this range and in the bitmap is removed,
// and any integer present in the range and not in the bitmap is added.
// The function uses 64-bit parameters even though a Bitmap stores 32-bit values because it is allowed and meaningful to use [0,uint64(0x100000000)) as a range
// while uint64(0x100000000) cannot be represented as a 32-bit value.
func (rb *Bitmap) Flip(rangeStart, rangeEnd uint64) {

	if rangeEnd > MaxUint32+1 {
		panic("rangeEnd > MaxUint32+1")
	}
	if rangeStart > MaxUint32+1 {
		panic("rangeStart > MaxUint32+1")
	}

	if rangeStart >= rangeEnd {
		return
	}

	hbStart := uint32(highbits(uint32(rangeStart)))
	lbStart := uint32(lowbits(uint32(rangeStart)))
	hbLast := uint32(highbits(uint32(rangeEnd - 1)))
	lbLast := uint32(lowbits(uint32(rangeEnd - 1)))

	var max uint32 = maxLowBit
	for hb := hbStart; hb <= hbLast; hb++ {
		var containerStart uint32
		if hb == hbStart {
			containerStart = uint32(lbStart)
		}
		containerLast := max
		if hb == hbLast {
			containerLast = uint32(lbLast)
		}

		i := rb.highlowcontainer.getIndex(uint16(hb))

		if i >= 0 {
			c := rb.highlowcontainer.getWritableContainerAtIndex(i).inot(int(containerStart), int(containerLast)+1)
			if !c.isEmpty() {
				rb.highlowcontainer.setContainerAtIndex(i, c)
			} else {
				rb.highlowcontainer.removeAtIndex(i)
			}
		} else { // *think* the range of ones must never be
			// empty.
			rb.highlowcontainer.insertNewKeyValueAt(-i-1, uint16(hb), rangeOfOnes(int(containerStart), int(containerLast)))
		}
	}
}

// FlipInt calls Flip after casting the parameters  (convenience method)
func (rb *Bitmap) FlipInt(rangeStart, rangeEnd int) {
	rb.Flip(uint64(rangeStart), uint64(rangeEnd))
}

// AddRange adds the integers in [rangeStart, rangeEnd) to the bitmap.
// The function uses 64-bit parameters even though a Bitmap stores 32-bit values because it is allowed and meaningful to use [0,uint64(0x100000000)) as a range
// while uint64(0x100000000) cannot be represented as a 32-bit value.
func (rb *Bitmap) AddRange(rangeStart, rangeEnd uint64) {
	if rangeStart >= rangeEnd {
		return
	}
	if rangeEnd-1 > MaxUint32 {
		panic("rangeEnd-1 > MaxUint32")
	}
	hbStart := uint32(highbits(uint32(rangeStart)))
	lbStart := uint32(lowbits(uint32(rangeStart)))
	hbLast := uint32(highbits(uint32(rangeEnd - 1)))
	lbLast := uint32(lowbits(uint32(rangeEnd - 1)))

	var max uint32 = maxLowBit
	for hb := hbStart; hb <= hbLast; hb++ {
		containerStart := uint32(0)
		if hb == hbStart {
			containerStart = lbStart
		}
		containerLast := max
		if hb == hbLast {
			containerLast = lbLast
		}

		i := rb.highlowcontainer.getIndex(uint16(hb))

		if i >= 0 {
			c := rb.highlowcontainer.getWritableContainerAtIndex(i).iaddRange(int(containerStart), int(containerLast)+1)
			rb.highlowcontainer.setContainerAtIndex(i, c)
		} else { // *think* the range of ones must never be
			// empty.
			rb.highlowcontainer.insertNewKeyValueAt(-i-1, uint16(hb), rangeOfOnes(int(containerStart), int(containerLast)))
		}
	}
}

// RemoveRange removes the integers in [rangeStart, rangeEnd) from the bitmap.
// The function uses 64-bit parameters even though a Bitmap stores 32-bit values because it is allowed and meaningful to use [0,uint64(0x100000000)) as a range
// while uint64(0x100000000) cannot be represented as a 32-bit value.
func (rb *Bitmap) RemoveRange(rangeStart, rangeEnd uint64) {
	if rangeStart >= rangeEnd {
		return
	}
	if rangeEnd-1 > MaxUint32 {
		// logically, we should assume that the user wants to
		// remove all values from rangeStart to infinity
		// see https://github.com/RoaringBitmap/roaring/issues/141
		rangeEnd = uint64(0x100000000)
	}
	hbStart := uint32(highbits(uint32(rangeStart)))
	lbStart := uint32(lowbits(uint32(rangeStart)))
	hbLast := uint32(highbits(uint32(rangeEnd - 1)))
	lbLast := uint32(lowbits(uint32(rangeEnd - 1)))

	var max uint32 = maxLowBit

	if hbStart == hbLast {
		i := rb.highlowcontainer.getIndex(uint16(hbStart))
		if i < 0 {
			return
		}
		c := rb.highlowcontainer.getWritableContainerAtIndex(i).iremoveRange(int(lbStart), int(lbLast+1))
		if !c.isEmpty() {
			rb.highlowcontainer.setContainerAtIndex(i, c)
		} else {
			rb.highlowcontainer.removeAtIndex(i)
		}
		return
	}
	ifirst := rb.highlowcontainer.getIndex(uint16(hbStart))
	ilast := rb.highlowcontainer.getIndex(uint16(hbLast))

	if ifirst >= 0 {
		if lbStart != 0 {
			c := rb.highlowcontainer.getWritableContainerAtIndex(ifirst).iremoveRange(int(lbStart), int(max+1))
			if !c.isEmpty() {
				rb.highlowcontainer.setContainerAtIndex(ifirst, c)
				ifirst++
			}
		}
	} else {
		ifirst = -ifirst - 1
	}
	if ilast >= 0 {
		if lbLast != max {
			c := rb.highlowcontainer.getWritableContainerAtIndex(ilast).iremoveRange(int(0), int(lbLast+1))
			if !c.isEmpty() {
				rb.highlowcontainer.setContainerAtIndex(ilast, c)
			} else {
				ilast++
			}
		} else {
			ilast++
		}
	} else {
		ilast = -ilast - 1
	}
	rb.highlowcontainer.removeIndexRange(ifirst, ilast)
}

// Flip negates the bits in the given range  (i.e., [rangeStart,rangeEnd)), any integer present in this range and in the bitmap is removed,
// and any integer present in the range and not in the bitmap is added, a new bitmap is returned leaving
// the current bitmap unchanged.
// The function uses 64-bit parameters even though a Bitmap stores 32-bit values because it is allowed and meaningful to use [0,uint64(0x100000000)) as a range
// while uint64(0x100000000) cannot be represented as a 32-bit value.
func Flip(bm *Bitmap, rangeStart, rangeEnd uint64) *Bitmap {
	if rangeStart >= rangeEnd {
		return bm.Clone()
	}

	if rangeStart > MaxUint32 {
		panic("rangeStart > MaxUint32")
	}
	if rangeEnd-1 > MaxUint32 {
		panic("rangeEnd-1 > MaxUint32")
	}

	answer := NewBitmap()
	hbStart := uint32(highbits(uint32(rangeStart)))
	lbStart := uint32(lowbits(uint32(rangeStart)))
	hbLast := uint32(highbits(uint32(rangeEnd - 1)))
	lbLast := uint32(lowbits(uint32(rangeEnd - 1)))

	// copy the containers before the active area
	answer.highlowcontainer.appendCopiesUntil(bm.highlowcontainer, uint16(hbStart))

	var max uint32 = maxLowBit
	for hb := hbStart; hb <= hbLast; hb++ {
		var containerStart uint32
		if hb == hbStart {
			containerStart = uint32(lbStart)
		}
		containerLast := max
		if hb == hbLast {
			containerLast = uint32(lbLast)
		}

		i := bm.highlowcontainer.getIndex(uint16(hb))
		j := answer.highlowcontainer.getIndex(uint16(hb))

		if i >= 0 {
			c := bm.highlowcontainer.getContainerAtIndex(i).not(int(containerStart), int(containerLast)+1)
			if !c.isEmpty() {
				answer.highlowcontainer.insertNewKeyValueAt(-j-1, uint16(hb), c)
			}

		} else { // *think* the range of ones must never be
			// empty.
			answer.highlowcontainer.insertNewKeyValueAt(-j-1, uint16(hb),
				rangeOfOnes(int(containerStart), int(containerLast)))
		}
	}
	// copy the containers after the active area.
	answer.highlowcontainer.appendCopiesAfter(bm.highlowcontainer, uint16(hbLast))

	return answer
}

// SetCopyOnWrite sets this bitmap to use copy-on-write so that copies are fast and memory conscious
// if the parameter is true, otherwise we leave the default where hard copies are made
// (copy-on-write requires extra care in a threaded context).
// Calling SetCopyOnWrite(true) on a bitmap created with FromBuffer is unsafe.
func (rb *Bitmap) SetCopyOnWrite(val bool) {
	rb.highlowcontainer.copyOnWrite = val
}

// GetCopyOnWrite gets this bitmap's copy-on-write property
func (rb *Bitmap) GetCopyOnWrite() (val bool) {
	return rb.highlowcontainer.copyOnWrite
}

// CloneCopyOnWriteContainers clones all containers which have
// needCopyOnWrite set to true.
// This can be used to make sure it is safe to munmap a []byte
// that the roaring array may still have a reference to, after
// calling FromBuffer.
// More generally this function is useful if you call FromBuffer
// to construct a bitmap with a backing array buf
// and then later discard the buf array. Note that you should call
// CloneCopyOnWriteContainers on all bitmaps that were derived
// from the 'FromBuffer' bitmap since they map have dependencies
// on the buf array as well.
func (rb *Bitmap) CloneCopyOnWriteContainers() {
	rb.highlowcontainer.cloneCopyOnWriteContainers()
}

// FlipInt calls Flip after casting the parameters (convenience method)
func FlipInt(bm *Bitmap, rangeStart, rangeEnd int) *Bitmap {
	return Flip(bm, uint64(rangeStart), uint64(rangeEnd))
}

// Statistics provides details on the container types in use.
type Statistics struct {
	Cardinality uint64
	Containers  uint64

	ArrayContainers      uint64
	ArrayContainerBytes  uint64
	ArrayContainerValues uint64

	BitmapContainers      uint64
	BitmapContainerBytes  uint64
	BitmapContainerValues uint64

	RunContainers      uint64
	RunContainerBytes  uint64
	RunContainerValues uint64
}

// Stats returns details on container type usage in a Statistics struct.
func (rb *Bitmap) Stats() Statistics {
	stats := Statistics{}
	stats.Containers = uint64(len(rb.highlowcontainer.containers))
	for _, c := range rb.highlowcontainer.containers {
		stats.Cardinality += uint64(c.getCardinality())

		switch c.(type) {
		case *arrayContainer:
			stats.ArrayContainers++
			stats.ArrayContainerBytes += uint64(c.getSizeInBytes())
			stats.ArrayContainerValues += uint64(c.getCardinality())
		case *bitmapContainer:
			stats.BitmapContainers++
			stats.BitmapContainerBytes += uint64(c.getSizeInBytes())
			stats.BitmapContainerValues += uint64(c.getCardinality())
		case *runContainer16:
			stats.RunContainers++
			stats.RunContainerBytes += uint64(c.getSizeInBytes())
			stats.RunContainerValues += uint64(c.getCardinality())
		}
	}
	return stats
}

func (rb *Bitmap) checkValidity() bool {
	for _, c := range rb.highlowcontainer.containers {

		switch c.(type) {
		case *arrayContainer:
			if c.getCardinality() > arrayDefaultMaxSize {
				fmt.Println("Array containers are limited to size ", arrayDefaultMaxSize)
				return false
			}
		case *bitmapContainer:
			if c.getCardinality() <= arrayDefaultMaxSize {
				fmt.Println("Bitmaps would be more concise as an array!")
				return false
			}
		case *runContainer16:
			if c.getSizeInBytes() > minOfInt(bitmapContainerSizeInBytes(), arrayContainerSizeInBytes(c.getCardinality())) {
				fmt.Println("Inefficient run container!")
				return false
			}
		}
	}
	return true
}

redpajama_set_name: RedPajamaGithub


Peralta's Adult High School Special Enrollment Program provides enrichment opportunities for adult high school students who can benefit from college level instruction.
Each college may admit a number of adult high school students in the GED or high school diploma program who have exceptional ability, or who desire specialized or advanced training. Such admission must be with the recommendation of the high school counselor and principal. **Other high-school students may be admitted on the basis of a contractual arrangement between the District and the high school of attendance (PCCDBP 5010).
Adult high school students enrolling in a College Level course must meet assessment requirements. The student must follow all the regulations and policies of the college, including adhering to any prerequisite requirements. It is recommended that the student brings an adult high school transcript to assist the college in determining the correct level of courses.
Special part-time adult high school students are exempted from paying the California Community College enrollment fees and all other fees. Adult high school students enrolled in more than 11.0 units are required to pay enrollment and all other mandatory fees (see the current Peralta Colleges class schedule for current health, campus use and transportation fees).
1. Remedial work (any classes in any discipline that are not college level and cannot be applied to an associate degree or higher). Remedial course numbers are generally 250 or higher. Check the college catalog for courses that area degree applicable.
2. Work to make up for failed high school or middle school classes.
4. Any class that can be taken at a local high school.


text:
Gabriela Johnson
College: Temple
Conference: American Athletic
Hometown: Mays Landing, NJ
Top 100 Ranking: N/A
Conference Top 20 Ranking:: N/A - American Athletic
@ Maryland 0 0 0 0 0 0 0 0 0 0 0.0
vs Penn 0 0 0 0 0 0 0 0 0 0 0.0
@ Towson 0 0 0 0 0 0 0 0 0 0 0.0
vs Rider 0 0 0 0 0 0 0 0 0 0 0.0
@ Saint Joseph's 0 0 0 0 0 0 0 0 0 0 0.0
@ Memphis* 0 0 0 0 0 0 0 0 0 0 0.0
vs Drexel 0 0 0 0 0 0 0 0 0 0 0.0
vs Cincinnati 0 0 0 0 0 0 0 0 0 0 0.0
vs Tulsa* 0 0 0 0 0 0 0 0 0 0 0.0
@ East Carolina* 0 0 0 0 0 0 0 0 0 0 0.0
vs Houston* 0 0 0 0 0 0 0 0 0 0 0.0
@ SMU* 0 0 0 0 0 0 0 0 0 0 0.0
@ UCF* 0 0 0 0 0 0 0 0 0 0 0.0
vs South Florida* 0 0 0 0 0 0 0 0 0 0 0.0


Ravenna residents are among the many satisfied customers we serve at Chuck's Auto Repair. Because we're easy to get to and have ASE-certified master mechanics and are AAA-certified for total car care, Ravenna friends have been coming to see us as long as we've been in business; with us, no customer ever has to visit multiple repair shops to have their vehicles serviced: we do everything right here, making life just that much easier.
Auto repair in Ravenna is available in many places. The question is, have the other auto repair shops achieved one of the TOP 5 spots during KING 5 TV's 'Best of Western Washington' contest? Chuck's has. Are their websites crammed with kudos from clients, the way ours is? We don't just make this stuff up; every testimonial you read here is certifiable.
It takes time, talent and technical abilities to earn the trust and votes of the people we serve. That's why seeing the vehicles of second-generation customers roll up to our Ravenna auto repair storefront to drop off their chariots always brings us such a sense of satisfaction and pride. It's proof positive that we're continuing to earn people's loyalty and affection.


Originally appeared in Asimov's Science Fiction.
My parents, Father especially, had little interest in the imagination. "Why would you read things that someone else made up?" he always wanted to know. We had no books of fiction in the house or a radio, and I didn't have many toys.
What I had was Thuria, and it was better. In the shadowy crawlspace beneath my house where only I could fit, I built a kingdom out of discarded sardine tins, thread spools, and cereal boxes. A wide boulevard wound between four hills to a colander capitol dome. There, King Wemnon and his twenty wise councilors benevolently discussed and executed their national affairs. Sometimes they called the men to arms to repel giant invading animals, usually the neighbor's cats. Often, they built elaborate fortifications along the frontier to defend against the evil Count Pappen and his massing armies. At least once, they sent lone heroes across the dusty wasteland to rescue poor Princess Annabella from the Tower of Eternal Woe.
A strange sensation of stretched time would overtake me when I visited Thuria, started by a sort of whispering trance, and I could perform whole epochs of its development in just a few stolen moments before dinner. Have you ever felt that way? It's a feeling of total absorption, the kind that seems to hum and fizz against the edges of your brain.


text:
(14960) Yule est un astéroïde de la ceinture principale.

Description
(14960) Yule est un astéroïde de la ceinture principale. Il fut découvert le  à Prescott (Arizona) par Paul G. Comba. Il présente une orbite caractérisée par un demi-grand axe de 2,57 UA, une excentricité de 0,06 et une inclinaison de 1,0° par rapport à l'écliptique.

Compléments

Articles connexes
 Liste des planètes mineures (14001-15000)
 Ceinture d'astéroïdes

Références

Planète mineure découverte en 1996
Astéroïde de la ceinture principale
Yule
Objet céleste découvert par Paul G. Comba

redpajama_set_name: RedPajamaWikipedia


Lepirudin and platelet aggregation inhibitors decrease your body's ability to make clots. When these two medicines are taken together, the effects of your lepirudin may be increased.
1.Refludan (lepirudin (rDNA)) US prescribing information. Berlex Laboratories October, 2002.
2.Cochran K, DeMartini TJ, Lewis BE, O Brien J, Steen LH, Grassman ED, Leya F. Use of lepirudin during percutaneous vascular interventions in patients with heparin-induced thrombocytopenia. J Invasive Cardiol 2003 Nov; 15(11):617-21.


Tax Considerations | Trilogy Metals Inc.
Certain Canadian and United States federal income tax consequences of the acquisition of Sunward Resources Ltd. are summarized in the joint information circular of NovaCopper Inc. and Sunward Resources Ltd. dated May 12, 2015, as filed on the NovaCopper website and available on SEDAR at www.sedar.com and EDGAR at www.sec.gov/edgar.shtml. Please refer to those summaries for more detailed information.
The Canadian and United States federal income tax consequences of the spin-out transaction are summarized in the Management Information Circular of NOVAGOLD dated February 27, 2012 and IRS Form 8937 dated March 4, 2013. A summary is provided below, please refer to the circular and Form 8937 for more detailed information.
The Board of Directors of NOVAGOLD determined that the fair value of each common share of NovaCopper is CDN$3.11 (US$3.13) which represents the trading price for NovaCopper shares on the NYSE MKT on days 6 through 10 following the effective date of the Arrangement of April 30, 2012. No determination of fair market value by NOVAGOLD is binding on Canadian and United States tax authorities, and shareholders should consult with their own tax advisors regarding what measure of fair market value is appropriate.


calories_per_serving: Int description: String food_category_id: Int food_category: food_category An object relationship id: Int! instructions: String name: String! number_of_servings: Int recipe_ingredients( limit: Int offset: Int order_by: [recipe_ingredient_order_by!] where: recipe_ingredient_bool_exp ): [recipe_ingredient!]! An array relationship source: String time_to_prepre: String vegetarian: Boolean!