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