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