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