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