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