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