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