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