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