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