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