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