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