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