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