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