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