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