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