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