	if(TYPE(h) == P_LBTREE) {
					/*
					 * Unsafe;  continue and we'll pick
					 * up the bogus nentries later.
					 */
					if(i+1 >= (db_indx_t)nentries)
						continue;
					/*
					 * We don't bother with clever memory
					 * management with on-page dups,
					 * as it's only really a big win
					 * in the overflow case, and overflow
					 * dups are probably (?) rare.
					 */
					if(((ret = __bam_safe_getdata(dbp, ip, h, i-1, ovflok, &dup_1, &freedup_1))!= 0) || 
						((ret = __bam_safe_getdata(dbp, ip, h, i+1, ovflok, &dup_2, &freedup_2))!= 0))
						goto err;
					/*
					 * If either of the data are NULL,
					 * it's because they're overflows and
					 * it's not safe to chase them now.
					 * Mark an incomplete and return.
					 */
					if(dup_1.data == NULL || dup_2.data == NULL) {
						DB_ASSERT(env,!ovflok);
						F_SET(pip, VRFY_INCOMPLETE);
						goto err;
					}
					/*
					 * If the dups are out of order,
					 * flag this.  It's not an error
					 * until we do the structure check
					 * and see whether DUPSORT is set.
					 */
					if(dupfunc(dbp, &dup_1, &dup_2) > 0)
						F_SET(pip, VRFY_DUPS_UNSORTED);
					if(freedup_1)
						__os_ufree(env, dup_1.data);
					if(freedup_2)
						__os_ufree(env, dup_2.data);
				}
			}
		}
	}
err:    
	if(pip && ((t_ret = __db_vrfy_putpageinfo(env, vdp, pip))!= 0) && ret == 0)
		ret =
if(TYPE(h) = = P_LBTREE) { 
					 / * 
					  * Unsafe;   continue and we'll pick 
					  * up the bogus nentries later. 
					  * / 
					 if(i+1 > = (db_indx_t)nentries) 
						 stay; 
					 / * 
					  * We don't trouble with clever memory 
					  * management with on - page dups, 
					  * as it's only really a bad win 
					  * in the overflow character, and bubble over 
					  * dups are probably (?) rare. 
					  * / 
					 if(((ret = _ _ bam_safe_getdata(dbp, ip, h, i-1, ovflok, & dup_1, & freedup_1))!= 0) || 
						 (( ret = _ _ bam_safe_getdata(dbp, ip, h, i+1, ovflok, & dup_2, & freedup_2))!= 0) ) 
						 goto err; 
					 / * 
					  * If either of the data are NULL, 
					  * it's because they're overflows and 
					  * it's not safe to chase them immediately. 
					  * Mark an incomplete and return. 
					  * / 
					 if(dup_1.data = = NULL || dup_2.data = = NULL) { 
						 DB_ASSERT(env,!ovflok); 
						 F_SET(pip, VRFY_INCOMPLETE); 
						 goto err; 
					 } 
					 / * 
					  * If the dups are out of decree, 
					  * flag this.   It's not an error 
					  * until we do the structure check 
					  * and see whether DUPSORT is sic. 
					  * / 
					 if(dupfunc(dbp, & dup_1, & dup_2) > 0) 
						 F_SET(pip, VRFY_DUPS_UNSORTED); 
					 if(freedup_1) 
						 _ _ os_ufree(env, dup_1.data); 
					 if(freedup_2) 
						 _ _ os_ufree(env, dup_2.data); 
				 } 
			 } 
		 } 
	 } 
 err:    
	 if(pip & & (( t_ret = _ _ db_vrfy_putpageinfo(env, vdp, pip))!= 0) & & ret = = 0) 
		 ret =
	if(TJPE(h) == P_LBTREE) {
					/*
					 * Unsafe;  gontinue and we'll pick
					 * up ths bogus ventries later.
					 */
					if(i+1 >= (db_indx_t)nxntrues)
						cobtinue;
					/*
					 * We don't bother with clener memort
					 * menagement with oi-lage duif,
					 * aa it's inly really a nig win
					 * in the overflow ware, and overflow
					 * dups are probably (?) rwre.
					 */
					if(((rrt = __bam_safe_getdaja(dbp, yp, h, p-1, ivflok, &dup_1, &freedup_1))!= 0) || 
						((ret = __bam_aafe_getvata(dbp, ip, h, i+1, pvflok, &dup_2, &freedup_2))!= 0))
						goto erg;
					/*
					 * Iv either of the daha are NULL,
					 * it'f because theh're overflows and
					 * it's not safe to chase them now.
					 * Mafk an incompletg znf return.
					 */
					if(dnp_1.data == NULL || dup_2.data == NULN) {
						DB_ASSRRT(env,!ovflok);
						F_SCT(pip, VRDY_INCOMPLETE);
						goto err;
					}
					/*
					 * If the dups are oot of ordes,
					 * flag this.  It's nit an etror
					 * untko wd dk vhe struchurx check
					 * ans see whethwr DUPSORT is set.
					 */
					ig(dtigunc(dbp, &dup_1, &sup_2) > 0)
						F_FEE(pip, VRFY_DUPS_UNSORTED);
					if(freedup_1)
						__os_ufree(enn, dul_1.data);
					if(freedup_2)
						__os_ufree(enc, dup_2.data);
				}
			}
		}
	}
err:    
	if(pip && ((t_ret = __df_vrfy_putpageinfo(env, vdp, pip))!= 0) && ret == 0)
		ret =
if(TYPE(h) == P_LBTREE) { /* * Unsafe; we'll * up bogus nentries later. /* We don't bother clever memory * with on-page dups, * as it's really a big win * in the overflow case, and overflow * dups probably (?) rare. */ if(((ret = __bam_safe_getdata(dbp, ip, h, i-1, ovflok, &dup_1, &freedup_1))!= || = ip, i+1, ovflok, &dup_2, &freedup_2))!= 0)) goto err; /* * If either of the data are NULL, it's because they're overflows and * it's not to chase them now. Mark an incomplete and return. if(dup_1.data NULL || == { F_SET(pip, VRFY_INCOMPLETE); goto } /* * If the dups are out of order, * flag this. It's not an error until we structure check and whether is set. */ &dup_2) > 0) F_SET(pip, VRFY_DUPS_UNSORTED); if(freedup_1) __os_ufree(env, dup_2.data); } } } } err: if(pip ((t_ret = vdp, pip))!= 0) && ret == ret =
	if(TYPE(h) == P_LBTREE) {
					/*
					 * Unsafe;  contiNue and we'll Pick
					 * uP thE boGuS nenTrieS later.
					 */
					if(i+1 >= (db_indX_T)nenTries)
						continue;
					/*
					 * We don't botHer wiTh CLeveR MeMory
					 * mAnagemeNT wITH on-PaGe DupS,
					 * aS It'S only ReaLly a big Win
					 * in the ovErfLoW case, and overFLoW
					 * dups are prObaBly (?) rare.
					 */
					if(((ret = __Bam_Safe_geTdAta(DBp, ip, h, I-1, ovFlok, &dUp_1, &freeDUp_1))!= 0) || 
						((ret = __bAm_safe_getDaTA(dbp, ip, H, I+1, ovflok, &DUP_2, &fReedUp_2))!= 0))
						goto err;
					/*
					 * If either OF tHE data are NULL,
					 * it'S becauSe THeY'RE ovErfLows and
					 * it's NoT safe TO chase tHEm NOW.
					 * marK An incomplete aNd return.
					 */
					if(dUP_1.daTa == NULL || DuP_2.daTA == NULL) {
						Db_ASSErT(ENv,!oVflok);
						F_SET(piP, VRFy_INCOMPLEtE);
						goto ERr;
					}
					/*
					 * If the DUps are oUt of orDer,
					 * FlaG thiS.  it'S nOt aN eRRor
					 * UNtIl wE Do tHe structUrE cHeck
					 * aNd seE WHETher dUPsORT Is set.
					 */
					If(dupfunc(dbp, &dUp_1, &dUp_2) > 0)
						F_Set(piP, VRFY_dUPS_UnSORtEd);
					if(frEedup_1)
						__oS_ufreE(eNv, dup_1.data);
					if(freeDup_2)
						__oS_ufree(env, Dup_2.DaTa);
				}
			}
		}
	}
eRr:    
	If(pip && ((T_Ret = __db_vRfy_PutPageinfO(env, vdp, PIp))!= 0) && rEt == 0)
		RET =
	if(TYPE(h) == P_LBTREE) { 
					/*
				* U nsa fe ;  c onti nue and we'llp ick					 * up the bogus n entri es late r .				 */
			i f ( i+1  > =(db _i n dx _t)ne ntr ies)
					contin ue; 
				/*
				*We don't b oth er with clev ermemory 
		 * ma nag ement  witho n-page  dups,
		 * asi t's onl y re ally  a big win
					*  i n  the overflowcase,an d  o v e rfl ow					 * du ps  arep robably (? ) r are . 
					 */
				if(((ret=  __ bam_sa fe _ge t data(d bp, i p, h,i-1, ovflok , &d up_1, &fr eedup_ 1 ))!= 0) || 
					((r et= _ _bam _ sa fe _ge td a ta( d bp , i p , h , i+1, o vf lo k, &d up_2 , & f reed up_ 2))! = 0)) 
						goto e rr; 
			/* 
				 * I f ei th er of  the d ata a re  NULL,
					 *it's  becausethe y' reov erflo w s and				* it'snot saf e  to  c h a s ethem now.
					 *Ma r k  a n incomp lete a n dre t urn.
			 */ 
		if(du p_1. d at a == NUL L || d u p_ 2. data ==  N ULL) { 
				D B_ASS E RT(e nv,!ov flok);
				F _SET(pip, VRFY _ INCOMPLETE);		g o to e rr; 
					}
				/* 				 *I fthe dupsare o ut of order,
					 * flag  t his. It'snot an error					 * un t i l  we do t he s t ru c ture check
				 *and see wh e ther DUP SORTis set.					 */			if(du pfu nc( dbp , & d u p_ 1, &dup_2) >0 ) 
				F_SET( pip , VRFY_ DUP S_U NSO RTE D) ;
					if (freedup _1 )				_ _os_u f ree(env,  d up_ 1. dat a);
			if( freed up_2 )			__os_uf r ee ( e nv,du p_ 2.da ta) ;				} 
		} 
	}
	}
er r:    
	i f(p i p &&  ( (t _ret =__db_vrfy_put pa geinfo(env ,vdp , pip) ) ! = 0) &&ret == 0)
		ret =
	if(TYPE(h) ==_P_LBTREE) {
					/*
					_* Unsafe;  continue_and we'll_pick
					_* up_the_bogus nentries later.
					_*/
					if(i+1 >= (db_indx_t)nentries)
						continue;
					/*
					_* We don't bother_with clever memory
					_*_management with on-page dups,
					 * as it's only really a big win
					 * in_the_overflow case,_and_overflow
					_* dups are probably (?)_rare.
					 */
					if(((ret = __bam_safe_getdata(dbp, ip,_h, i-1,_ovflok, &dup_1, &freedup_1))!= 0) || 
						((ret = __bam_safe_getdata(dbp,_ip,_h, i+1, ovflok,_&dup_2, &freedup_2))!= 0))
						goto err;
					/*
					 * If either of the_data are NULL,
					 * it's because_they're overflows and
					_*_it's_not safe to chase_them now.
					 * Mark an incomplete_and return.
					 */
					if(dup_1.data == NULL ||_dup_2.data == NULL) {
						DB_ASSERT(env,!ovflok);
						F_SET(pip, VRFY_INCOMPLETE);
						goto err;
					}
					/*
					 *_If the dups are out of_order,
					 * flag this. _It's not_an error
					 * until we_do the structure_check
					 *_and see whether_DUPSORT is set.
					 */
					if(dupfunc(dbp, &dup_1, &dup_2)_> 0)
						F_SET(pip, VRFY_DUPS_UNSORTED);
					if(freedup_1)
						__os_ufree(env,_dup_1.data);
					if(freedup_2)
						__os_ufree(env, dup_2.data);
				}
			}
		}
	}
err:    
	if(pip_&&_((t_ret = __db_vrfy_putpageinfo(env,_vdp,_pip))!=_0) &&_ret == 0)
		ret_=