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