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