Page Banner

United States Department of Agriculture

Agricultural Research Service

Related Topics

Bibliography_December2008
headline bar
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