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