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