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