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