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