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