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