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