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